PAT (Advanced Level) Practice-1003 Emergency (25 分)

题目要求

As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in each city and the length of each road between any pair of cities are marked on the map. When there is an emergency call to you from some other city, your job is to lead your men to the place as quickly as possible, and at the mean time, call up as many hands on the way as possible.
(作为一个城市救援队的领导，你拥有一张特殊的城市地图。这张地图展示了几个零落的由道路连接的城市。每个城市救援队的数量以及两个城市之间的道路长度都被标出。当紧急情况发生时，你的工作就是要决定如何尽快地领导自己的队伍前往事发地点，而且要尽可能多地聚集每个结点的帮手)

Input Specification:

Each input file contains one test case. For each test case, the first line contains 4 positive integers: N (≤500) - the number of cities (and the cities are numbered from 0 to N−1), M - the number of roads, C​1 and C​2
​​ - the cities that you are currently in and that you must save, respectively. The next line contains N integers, where the i-th integer is the number of rescue teams in the i-th city. Then M lines follow, each describes a road with three integers c1, c2
​​ and L, which are the pair of cities connected by a road and the length of that road, respectively. It is guaranteed that there exists at least one path from C1 to C​2
​​ .

Output Specification:

For each test case, print in one line two numbers: the number of different shortest paths between C1 and C2
​​ , and the maximum amount of rescue teams you can possibly gather. All the numbers in a line must be separated by exactly one space, and there is no extra space allowed at the end of a line.

Sample Input:

1
2
3
4
5
6
7
8

5 6 0 2
1 2 1 5 3
0 1 1
0 2 2
0 3 1
1 2 1
2 4 1
3 4 1

Sample Output:

1

2 4

这是一个很典型的搜索问题，通过搜索，获得最短边权和以及最大点权和。
这就引出了我们接下来的算法

–DFS–深度优先搜索

这算法的主要思想是啥呢？

• 首先，我们需要得到一个地图，记录这某些对点之间的距离（当然也有可能记录着每个点的权重)，以及定义一个最短路径当作全局的一种变量（初始值一般是无穷大)。
• 其次，我们需要一个起始点和一个终点，以及一个表，记录某条路是否走过。
• 最后，从起点开始，遍历其他的点，比如我们从0这个城市开始，想去4这个城市，接下来我们看看0->1，那么这个0->1这个路径就要被标记为已经走过，然后又递归进入本函数，一直递归递归，1->2, 2->6……直到递归到起点是我们之前的目的地，那么接下来我们就可以判断了，如果这条路径的总长度小于之前定义的最短路径，那么我们就将最短路径更新为这个新值（因为初始值一般定义为无穷大，所以第一次遍历时一定会更新)，到了最后一步，开始return,一层一层地return，直到回到最初的起点，每一层在获得前一层的return后就要进行下一步，把之前标记为已经走过的道路再重新标记为没走过，这个是很重要的，因为我们的目的不是要标记路走没走过，目的是为了更新最短路径。那么在接下来的搜索中，如果当前的路程已经大于之前更新过的最短路径了，那就啥都憋suo了~，return就完了

针对这个题目，我们可以先看看怎么解

上代码 (ﾉ◕ヮ◕)ﾉ:･*ﾟ✧

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

package 最短路径;

import java.nio.file.Path;
import java.sql.SQLNonTransientConnectionException;
import java.util.Scanner;

public class DFS {

static int n = 0;
static int m = 0;
static int c1 = 0;
static int c2 = 0;
static int[][] map = new int[500][500];
static int[] weight = new int[500];
    static boolean[][] visit = new boolean[500][500];
    static int totalPath = 0;
    static int totalWehght = 0;
    static int minPath = Integer.MAX_VALUE;
    
    public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    n = scanner.nextInt();
    m = scanner.nextInt();
    c1 = scanner.nextInt();
    c2 = scanner.nextInt();
    
    for(int i = 0; i < n; i++) {
    weight[i] = scanner.nextInt();
    }
    
    for(int i = 0; i < m; i++) {
    int x = scanner.nextInt();
    int y = scanner.nextInt();
    int z = scanner.nextInt();
    map[x][y] = map[y][x] = z;
    }
    dfs(c1, 0, weight[c1]);
    System.out.println(totalPath+" "+totalWehght);
    }
    
    //这个算法就是整个解题的灵魂
    static void dfs(int start, int Lpath, int weights) {
        //判断如果到达了终点
    if(start == c2) {
    if(Lpath < minPath) {
                //突然发现这个路径的长度比上一次更新的还短，那就把最短路径的个数更新为1
    totalPath = 1;
    minPath = Lpath;
    totalWehght = weights;
    }else if(Lpath == minPath) {
                //突然发现最短路径跟上次一样，这两条路径在长度上是等价的，加上这个路径
    totalPath++;
    if(totalWehght < weights) {
    totalWehght = weights;
    }
    }
    
    return;
    }
    
    if(Lpath > minPath) {
            //不管你运行到哪个结点了，只要发现你的路径长度比上一次更新过的长，直接就别往下走了
    return;
    }
    
    for(int i = 0; i < n; i++) {
            //从起点（每一次循环的起点，你这次的终点就是下一次的起点）开始遍历其他的没有走过的点，并且起点与该点之间的距离不能为零
    if(!visit[start][i] && map[start][i] != 0) {
                //先把这个路径设为已经走过了
    visit[start][i] = visit[i][start] = true;
                //开始递归，把这次的终点当作下次的起点，计算新的路径长度，计算新的点权重和
    dfs(i, Lpath + map[start][i], weights + weight[i]);
                //上面这个递归结束了，那就把之间的标记给去掉
    visit[start][i] = visit[i][start] = false;
    }
    }
    
    return;
    }

}

//相信你通过这个题应该就能大体上看懂了DFS算法了

总结：

• 其实也不是特别难懂
• 算法很精妙
• 时间复杂度应该是O(n^2),还不是特别恐怖。

一篇文章搞定面试中的链表题目(java实现)

Java实现单链表的插入、删除、计算链表的长度和输出链表

链表顾名思义就是一种带链子的表，一环扣一环。每一个环节都可分成两个部分，一部分是数据，一部分是指向下一个环节的指针。

如果要定义一个链表环节可以这么做

1
2
3
4
5
6
7
8
9
10

public class ListNode {

int data;//data就是每个环节所存储的数据
ListNode next = null;//next用来储存下一个环节的地址

public  ListNode(int data) {
this.data = data;
}

}

当我们使用的时候，可以这样

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

public class Main {

public static void main(String[] args) {

Main myMain = new Main();


ListNode l1 = null;
l1 = myMain.insertNode(1, l1);
myMain.insertNode(2, l1);
myMain.insertNode(3, l1);

ListNode l2 = null;
l2 = myMain.insertNode(1, l2);
myMain.insertNode(2, l2);
myMain.insertNode(3, l2);

ListNode node = myMain.addTowNode(l1, l2);
myMain.printNodelist(node);
}


//这个方法是用来循环打印数据
public static void printNodelist(ListNode listNode) {
ListNode node = listNode;
while(node != null) {
System.out.print(node.data+" ");
node = node.next;
}

System.out.println();
}




//往链表中插入数据
public ListNode insertNode(int data, ListNode node) {

ListNode head = new ListNode(data);
if(node == null) {
node = head;
return node;
}

ListNode temp = node;
while(temp.next != null) {
temp = temp.next;
}

temp.next = head;
return node;
}

    //将两个链表的每个数据进行相加
public ListNode addTowNode(ListNode l1, ListNode l2) {
ListNode p = l1;
ListNode q = l2;
ListNode head = null;
int carry = 0;
while(p != null || q != null) {
int x = (p != null)?p.data:0;
int y = (q != null)?q.data:0;
int sum = x + y;
head = insertNode(sum % 10, head);
carry = sum / 10;

if(p != null) {
p = p.next;
}

if (q != null) {
q = q.next;
}
}

if(carry > 0) {
head.next = new ListNode(carry);
}

return head;
}
}

在leetcode中的题目是这样要求的：

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

1
2
3

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

看看我这修改了无数遍的答案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
//    public static ListNode insertNode(int data, ListNode node) {

// ListNode head = new ListNode(data);
// if(node == null) {
// node = head;
// return node;
// }

// ListNode temp = node;
// while(temp.next != null) {
// temp = temp.next;
// }

// temp.next = head;
// return node;
// }

public  ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode p = l1;
ListNode q = l2;
ListNode head = new ListNode(0);//这里使用了哑节点，不需要判断空值情况
         ListNode curr = head;
int carry = 0;
while(p != null || q != null) {
int x = (p != null)?p.val:0;
int y = (q != null)?q.val:0;
int sum = x + y + carry;
// head = insertNode(sum % 10, head);
            
           
//             if(curr == null){
//                 curr = new ListNode(sum % 10);
//             }else{
//                 curr.next = new ListNode(sum % 10);
//                 curr = curr.next;
//             }
           curr.next = new ListNode(sum % 10);
            curr = curr.next;
            
            
carry = sum / 10;

if(p != null) {
p = p.next;
}

if (q != null) {
q = q.next;
}
}

if(carry > 0) {
curr.next = new ListNode(carry);
}

return head.next;
}
}

看看真正的哑结点的用法

链表 - 哑节点

定义结构体

1
2
3
4

struct ListNode {
    int val;
    struct ListNode *next;
};

如果引入了哑节点的，函数就可以得到简化，

在调用addNode()函数之前，我们先定义哑节点

1
2
3

struct ListNode *dummyNode= (struct ListNode*) malloc( sizeof(struct ListNode)  );
dummyNode->val = null;
dummyNode->next = null;

使用

1
2
3
4
5
6

ListNode *addNode( ListNode *dummyNode, int num){// 函数返回的是尾节点
    struct ListNode *new = (struct ListNode*) malloc( sizeof(struct ListNode) * num );
    /* 此处不再需要处理头节点为空的情况，因为dummyNode一定非空 */
    dummyNode->next = new;
    return new;
}

Paging是Google 2018 IO大会最新发布的Jetpack中的一个组件，主要用于大数据的分页加载

需要补充的知识

• 接口回调
  通过点击事件监听 setOnClickListener 彻底理解回调-Android

• Room
  Android Room的详细介绍

  Android架构组件Room的使用(适合进阶)

• Java注解和反射
  JAVA 注解的基本原理
  Java 反射由浅入深 | 进阶必备
  Java反射（包含getMethod以及invoke）
  搞定代理模式,看懂Retrofit动态代理的骚操作

• LiveData
  Android应用结构之LiveData

• ViewModel
• RxJava
  这可能是最好的RxJava 2.x 教程（完结版）

我的理解

首先来说，paging框架应该分成三部分：Data, ViewModel, UI

Data

• Data是数据的提供者，数据的来源可以是后端返回数据，也可以是Room数据库存贮，当然也可以是本地数据。
• Data可以分成两部分：DataSource和DataSourceFactory。DataSourceFactory继承DataSource.Factory,是用来创建DataSource的途径。
  • DataSource

和page相关的3种DataSource的区别
Android Paging分页组件的使用及原理
我所理解的 RxJava——上手其实很简单（二）(publishSubject的使用)
大话Android多线程(一) Thread和Runnable的联系和区别
30 分钟入门 Java8 之 lambda 表达式

1. DataSource可以利用Retrofit等方式，通过传入代理类进行数据请求，将数据返回到被观察的LiveData中。
2. 设置可取消类Disposable,防止内存泄漏???????
3. PositionalDataSource中需要实现两种方法：LoadInitial, LoadRange.进行数据请求时代理类中的参数有：初始请求的数据位置(startpostion)，每次请求的页数(pagesize), PagaingCallback接口实例（这个是自定义的）

4. 无论是LoadInitial还是LoadRange,方法参数都有callback, callback都有一个方法onResult(List<>), 调用这个方法，便可将数据传送到被观察的数据中。

   5. 与此同时，在请求前，请求成功以及请求失败时，都应更新ViewModel对应的网络状态。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96

   public class PagingDataSource<T> extends PositionalDataSource<T> implements DataSource.InvalidatedCallback { private Runnable mRetry; private PagingViewModel<T> mViewModel; private PagingRepository mApi; private final CompositeDisposable mDisposable = new CompositeDisposable(); public PagingDataSource(PagingViewModel<T> viewModel, PagingRepository api) { this.mViewModel = viewModel; this.mApi = api; //registerRetry返回的是一个publishSubject,可以用来简化订阅过程 register(mViewModel.registerRetry().subscribe(s -> { if (mRetry != null) { mRetry.run(); mRetry = null; } }, Throwable::printStackTrace));//这里mViewModel正式被一个线程订阅，检测其变化？？？？？？？？？？？？？？？？？ //这个额。为啥一定要出现？？？？？？？？？？？？ addInvalidatedCallback(this); } //防止出现内存泄漏 private void register(Disposable disposable) { mDisposable.add(disposable); } @Override public void loadInitial(@NonNull LoadInitialParams params, @NonNull LoadInitialCallback<T> callback) { //更新mViewModel里的网络状态量 mViewModel.getRefreshState().postValue(NetworkStatus.loading()); //这里请求的过程后面会重写 mApi.getDataList(0, PagingViewModel.INIT_LOAD_SIZE, new PagingCallBack() { @Override public void onSuccess(List list) { //更新网络状态 mViewModel.getRefreshState().postValue(NetworkStatus.success())； //设置hasMore里持有量为true，说明还有更多的数据 mViewModel.hasMore().postValue(true); if (isEmptyList(list)) { //onResult方法会将数据直接发送到检测这个LiveData的UI进程中。 callback.onResult(new ArrayList<>(), 0); } else { callback.onResult(new ArrayList(list), 0); } } @Override public void onError(Exception e) { mViewModel.getRefreshState().postValue(NetworkStatus.error()); //重新进行初始化数据请求 mRetry = () -> loadInitial(params, callback); } }); } @Override public void loadRange(@NonNull LoadRangeParams params, @NonNull LoadRangeCallback<T> callback) { mViewModel.getLoadingState().postValue(NetworkStatus.loading()); mApi.getDataList(params.startPosition, PagingViewModel.PAGE_SIZE, new PagingCallBack() { @Override public void onSuccess(List list) { mViewModel.getLoadingState().postValue(NetworkStatus.success()); if (isEmptyList(list)) { callback.onResult(new ArrayList<>()); } else { callback.onResult(list); } } @Override public void onError(Exception e) { mViewModel.getLoadingState().postValue(NetworkStatus.error()); mRetry = () -> loadRange(params, callback); } }); } private boolean isEmptyList(List list) { return list == null || list.isEmpty(); } //这个应该是取消订阅或者销毁线程的时候用到的，不用太管它 @Override public void onInvalidated() { removeInvalidatedCallback(this); mDisposable.clear(); } }

• DataSourceFactory

1. 这个就很简单了，创建一个Multabel<DataSource>, 创建构造方法，重写create方法，这个会在接下来的ViewModel中用到。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   public class PagingDataSourceFactory<T> extends DataSource.Factory<Integer, T> { private MutableLiveData<PagingDataSource<T>> mDataSource = new MutableLiveData<>(); public PagingDataSourceFactory(PagingDataSource<T> dataSource) { mDataSource.setValue(dataSource); } @Override public DataSource<Integer, T> create() { return mDataSource.getValue(); } public MutableLiveData<PagingDataSource<T>> getDataSource() { return mDataSource; } }

ViewModel

• 如果说Data部分是数据的储藏车间，那么viewmodel进行的工作就是将数据按照特定的格式，每次定量地从车间搬运，从而在UI上显示数据的更新。

  • PagingViewModel(extends ViewModel)

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94

    public abstract class PagingViewModel<T> extends ViewModel { //设置初始化请求量 public static final int INIT_LOAD_SIZE = 20; //设置请求页数 public static final int PAGE_SIZE = 20; private LiveData<PagedList<T>> mDataList; private MutableLiveData<NetworkStatus> mRefreshState = new MutableLiveData<>(); protected MutableLiveData<NetworkStatus> mLoadingState = new MutableLiveData<>(); protected MutableLiveData<Boolean> isEmpty = new MutableLiveData<>(); protected MutableLiveData<Boolean> hasMore = new MutableLiveData<>(); private PublishSubject<String> retry = PublishSubject.create(); private PagingDataSourceFactory<T> mFactory; //初始化数据，得到一个包含DataSource的DataSourceFactory的实例 public PagingViewModel() { if (mDataList == null) { mFactory = new PagingDataSourceFactory<>(getDataSource()); mDataList = buildPagedList(); } } //这一步很重要，这一步直接将ViewModel与DataSourceFactory对接，从DataSourceFactory里面得到DataSource的实例，LivePagedListBuilder<>()方法 中需要传入的参数是继承Data.Factory的类和一个配置Config,getConfig是在下面自定义的方法，配置了PagedList.Config。最后返回的数据就是一个LiveData<PgaedList<T>>. private LiveData<PagedList<T>> buildPagedList() { isEmpty.setValue(false); return new LivePagedListBuilder<>(mFactory, getConfig()) //setBoundaryCallback是在数据耗尽后进行的回调传参，其中PagingBoundaryCallback<T>为自定义类，继承自PagedList.BoundaryCallback<T> .setBoundaryCallback(new PagingBoundaryCallback<>(hasMore, isEmpty)) .build(); } public LiveData<PagedList<T>> getDataList() { return mDataList; } public MutableLiveData<NetworkStatus> getLoadingState() { return mLoadingState; } public MutableLiveData<NetworkStatus> getRefreshState() { return mRefreshState; } public MutableLiveData<Boolean> isEmpty() { return isEmpty; } public MutableLiveData<Boolean> hasMore() { return hasMore; } //publishSubject可以当作一个observerble,发送消息("retry"); //在PagingDataSource中被订阅 //好吧这个我实在不知道他多此一举是为什么？？？？？？？？？？ public void retry() { retry.onNext("retry"); } public void refresh() { mDataList = buildPagedList(); } public void showList(List<T> list) { if(mDataList.getValue()!=null) { mDataList.getValue().clear(); mDataList.getValue().addAll(list); } } public PublishSubject<String> registerRetry() { return retry; } private PagedList.Config getConfig() { return new PagedList.Config.Builder() //配置分页加载的数量 .setPageSize(PAGE_SIZE) //配置是否启动PlaceHolders .setEnablePlaceholders(false) //初始化加载的数量 .setInitialLoadSizeHint(INIT_LOAD_SIZE) .build(); } //在后面继承PagingViewModel的类中具体实现，从而能够构造PagingDataSourceFactory protected abstract PagingDataSource<T> getDataSource(); }

• PagingListAdapter
  深入理解Java 8 Lambda（语言篇——lambda，方法引用，目标类型和默认方法

## 老铁顶住，我要放大招了：##

刺激不 （ ๑乛◡乛๑ ）（一点一点地看）

• 首先我们先看adapter的构造方法

  1 2 3 4 5

  protected PagingListAdapter(@NonNull DiffUtil.ItemCallback<T> diffCallback, LifecycleOwner owner) { super(diffCallback); mLifecycleOwner = owner; }

  里面需要传入两个参数，一个是DiffUtil.ItemCallback, 一个是LifecycleOwner，DiffUtil.ItemCallback是在继承pagingListAdapter的类中根据实际情况实现的。

  这个diffutil.itemcallback的传入是很讲究滴。

  在adapter构造完成后，传入一个已经写好的DiffUitl.ItemCallback实例，继续传入到AsyncPagedListDiffer中，最后一路传入PagedStorageHelper中。

1
2
3
4
5

protected PagedListAdapter(@NonNull DiffUtil.ItemCallback<T> diffCallback) {
  //这是PagedListAdapter的构造函数，调用了AsyncPagedListDiffer的构造函数
        mDiffer = new AsyncPagedListDiffer<>(this, diffCallback);
        mDiffer.mListener = mListener;
    }

而在adapter中可以调用一个submitList方法，如下图，调用了PagedListAdapter的submitList方法，从而调用了AsyncPagedListDiffer的submitList方法。

1
2
3
4
5
6

//AsyncPagedListDiff.java 149行 这个构造是从PagedListAdapter调过来的
public AsyncPagedListDiffer(@NonNull RecyclerView.Adapter adapter,
           @NonNull DiffUtil.ItemCallback<T> diffCallback) {
       mUpdateCallback = new AdapterListUpdateCallback(adapter);
       mConfig = new AsyncDifferConfig.Builder<T>(diffCallback).build();
   }

1
2
3
4

//PagedListAdapter 150行
 public void submitList(PagedList<T> pagedList) {
        mDiffer.submitList(pagedList);
    }

在AsyncPagedListDiffer的submitList方法中，调用了PagedStorageDiffHelper的computeDiff方法，通过之前传入的回调实例，得到一个DiffResult.

1
2
3
4
5
6
7

//PagedStorageDiffHelper.java 37行 获取result
{ 
  static <T> DiffUtil.DiffResult computeDiff(······)
          //······//
    return diffCallback.getChangePayload(oldItem, newItem);
 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

 //AsyncPagedListDiffer.java 230行

  public void submitList(final PagedList<T> pagedList){
              
              //······//
           
            mConfig.getBackgroundThreadExecutor().execute(new Runnable() {
            @Override
            public void run() {
                final DiffUtil.DiffResult result;
                //调用PagedStorageHelper的computeDiff方法得到DiffResult
                result = PagedStorageDiffHelper.computeDiff(
                        oldSnapshot.mStorage,
                        newSnapshot.mStorage,
                        mConfig.getDiffCallback());

                mMainThreadExecutor.execute(new Runnable() {
                    @Override
                    public void run() {
                        if (mMaxScheduledGeneration == runGeneration) {
                  
                          //***********************调用了如下方法
                            latchPagedList(pagedList, newSnapshot, result);
                          //************************
                        }
                    }
                });
            }
        });

  }
  

        private void latchPagedList(
            PagedList<T> newList, PagedList<T> diffSnapshot,
            DiffUtil.DiffResult diffResult) {
        if (mSnapshot == null || mPagedList != null) {
            throw new IllegalStateException("must be in snapshot state to apply diff");
        }

        PagedList<T> previousSnapshot = mSnapshot;
        mPagedList = newList;
        mSnapshot = null;
//mUpdateCallback = new AdapterListUpdateCallback(adapter);
        
        PagedStorageDiffHelper.dispatchDiff(mUpdateCallback,
                previousSnapshot.mStorage, newList.mStorage, diffResult);//result在这里出现了***************继续点击进去这个方法

        newList.addWeakCallback(diffSnapshot, mPagedListCallback);
        if (mListener != null) {
            mListener.onCurrentListChanged(mPagedList);
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

//PagedStorageDiffHelper result将数据发送给adapter

static <T> void dispatchDiff(ListUpdateCallback callback,
            final PagedStorage<T> oldList,
            final PagedStorage<T> newList,
            final DiffUtil.DiffResult diffResult) {

        final int trailingOld = oldList.computeTrailingNulls();
        final int trailingNew = newList.computeTrailingNulls();
        final int leadingOld = oldList.computeLeadingNulls();
        final int leadingNew = newList.computeLeadingNulls();

        if (trailingOld == 0
                && trailingNew == 0
                && leadingOld == 0
                && leadingNew == 0) {
            // Simple case, dispatch & return 发送数据给adapter
            diffResult.dispatchUpdatesTo(callback);
            return;
        }

         //········//
        
  
}

后续的直接看注释就可以了dispatchUpdatesTo方法传入的其实就是一个adapter，所以很显然，这些数据最终会发到adapter并且进行数据更新。再深入我也搞不来了，以后再说吧，先留个坑。

其实到现在我们只是这么说，但是如何让数据更新时将新数据发送，实现submitList方法？这个我也没特别看懂。就比如下面这些，在adapter里的利用Java 8 Lambda方法的 this :: submitList 为什么能够返回Observer? 它是如何实现动态submitList的？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// 监听数据列表变化
   private final Observer<PagedList<T>> mDataListObserver = this::submitList;




   // 监听LoadMore状态
   private final Observer<NetworkStatus> mLoadingObserver = networkStatus -> {
       if (networkStatus == null) {
           return;
       }
       setLoadingStatus(networkStatus.getStatus());
   };

   // 监听Refresh状态
   private final Observer<NetworkStatus> mRefreshObserver = networkStatus -> {
       if (networkStatus == null) {
           return;
       }
       setRefreshStatus(networkStatus.getStatus());
   };

   // 监听是否为空列表
   private final Observer<Boolean> mEmptyObserver = isEmpty -> {
       if (isEmpty == null) {
           return;
       }
       setEmpty(isEmpty);
   };

   // 监听是否有更多
   private final Observer<Boolean> mHasMoreObserver = hasMore -> {
       if (hasMore == null) {
           return;
       }
       setHasMore(hasMore);
   };

为什么要这么写呢？其实这个就是lambda语法里面比较狗的地方了
先看个例子吧

1
2
3
4
5
6
7
8

//这是一段我从别的地方进行实验后搬来的代码，跟整体无关，
//这个说明了如果我们想对LiveData设置监听的话，必须传入一个LifeRecyclerOwner,一个Observer
 feedViewModel.getArticleLiveData().observe(this, new Observer<PagedList<Article>>() {
            @Override
            public void onChanged(@Nullable PagedList<Article> articles) {
                adapter.submitList(articles);
            }
        });

所以学长的骚操作完全可以有三种方法实现

• 第一种 菜鸡乖乖写法

  1 2 3 4 5 6 7

  // private final Observer<PagedList<T>> observer = new Observer<PagedList<T>>() { @Override public void onChanged(@Nullable PagedList<T> ts) { getAdapter().submitList(ts); } };

• 第二种，小小进阶

  1	private final Observer<PagedList<T>> observer = ts -> this.submitList(ts);

• 第三种，灵魂代码手

  1	private final Observer<PagedList<T>> mDataListObserver = this::submitList;

关于数据的绑定问题

之前一直被我忽略掉了bindViewHolder方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

@Override
   public void onBindViewHolder(@NonNull RecyclerView.ViewHolder viewHolder, int position) {
       int type = getItemViewType(position);
       //前三种可能都是处理的异常情况

       //1.数据请求到底，没有数据可返回
       if (type == TYPE_EMPTY && viewHolder instanceof EmptyViewHolder) {
           ((EmptyViewHolder) viewHolder).bind((showLoadingStatusView() && isAtEnd()), isEmpty());

       //2.正在加载数据
       } else if (type == TYPE_LOADING && viewHolder instanceof LoadingViewHolder) {
           ((LoadingViewHolder) viewHolder).bind();

       //3.数据出现错误
       } else if (type == TYPE_ERROR && viewHolder instanceof ErrorViewHolder) {
           ((ErrorViewHolder) viewHolder).bind(showLoadingStatusView());
       //4.正常情况，调用viewholder的bind方法，将data传入
       } else if (viewHolder instanceof BaseViewHolder) {
           T data = getItem(position);
           ((BaseViewHolder<T>) viewHolder).bind(data, position);
       }
   }

如果这时候我们点进去getItem方法，发现这个是PagedListAdapter的方法，其中由使用了mDiffer.getItem()方法。

1
2
3
4

@Nullable
    protected T getItem(int position) {
        return mDiffer.getItem(position);
    }

这个mDiffer是个什么鬼？如果这时候你往上翻滚本文，在adapter实现过程的源码分析环节就可以看到这个mDiffer,这个是AsyncPagedListDiffer类的一个实例，我们之前知道了，当adapter调用了submit方法后，里面需要传入一个PagedList，然后这个pagedList就会赋值给AsyncPagedListDiffer里面的mPagedList,然后在getItem方法中可以通过mPagedList，根据位置调取单个实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Nullable
    public T getItem(int index) {
        if (mPagedList == null) {
            if (mSnapshot == null) {
                throw new IndexOutOfBoundsException(
                        "Item count is zero, getItem() call is invalid");
            } else {
                return mSnapshot.get(index);
            }
        }

        mPagedList.loadAround(index);
        return mPagedList.get(index);
    }

得到了单个item的data后，我们就可以将data和position传入viewholder类实例的bind方法，那么在自定义的viewholder继承BaseViewHolder，可以实现bind方法，将data与view绑定
以PriceItemViewHolder为例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//重写了bind方法，参数为data,将数据与视图绑定
 @Override
    public void bind(Jade data, int position) {

        mGoodsTitleTxt.setText(data.getTitle());
        mRangeTxt.setText(warpPercent(Math.abs(data.getRange())));
        mSpeedTxt.setText(warpPercent(Math.abs(data.getSpeed())));
        mRangeLabelTxt.setText(data.getRange() >= 0
                ? R.string.price_label_range_rise
                : R.string.price_label_range_drop);
        mSpeedLabelTxt.setText(data.getSpeed() >= 0
                ? R.string.price_label_speed_rise
                : R.string.price_label_speed_drop);
        Glide.with(itemView).load(data.getCover()).into(mCoverImg);

        if (withOrder) {
            mRankOrder.setText(String.valueOf(position + 1));
            mRankOrder.setVisibility(View.VISIBLE);
        } else {
            mRankOrder.setVisibility(View.GONE);
        }
    }

总结（UI部分还没看，先这么写一些）

Data

• PagingDatasource用来请求数据，并且将数据返回给观察它的类。
• PagingDtaSourceFactory是用来创建DataSource的实例的工具。

  ViewModel

• PagingViewModel是能够创建各种LiveData的类，其中包括最重要的LiveData<PagedList<T>>,通过LivePagedListBuilder，传入PagingDataSourceFactory和Config（Config是配置类，规定了请求页数，初始请求数量等一些基本配置），最终得到需要的LiveData<PagedList<T>>.

  PaginListAdapter继承PagedListAdapter

  • 构造方法：构造方法中需要传入DiffUtil.ItemCallback类。而且在adapter中可以实现submitList(LiveData<PagedLsit>)方法，从而实现对数据变换的监视，数据变动时会发送给adapter.(更新2019.8.2)： 今天更加深入理解之后，进行一个新的解释，在adapter里面实现了对LiveData的观察，当LiveData发生变动时，会调用submitList方法，将变动的数据传入，然后结合我上面的那些调用过程，在调用的过程大部分是在DiffUtil.itemCallback的包装类中，所以一定使用了DiffUtil.itemcallback类（在具体使用时实现）中的对比方法，从而只将变动的数据传回adapter，提高了效率。
  • 添加setViewModel方法：在活动中可以创建ViewModel实例，从而将实例传给adapter
  • 提供抽象函数 CreateNormalViewHolder,用来创建不同页面的viewHolder.

使用

又可能上面这些东西你都看得觉得无比头疼，心想着我只需要知道怎么用就行了呀。行，那咱们就结合实例讲一讲怎么用

• 首先是ViewModel,由于增哥已经把PagingViewModel封装得很全面了，你只需要实现里面的抽象方法
  protected abstract PagingDataSource<T> getDataSource();
  例如我们进行一个请求

  1 2 3 4 5 6 7 8 9 10 11 12 13 14

  public interface PersonalApi { /** * 获取我的预约评估列表 * * @param checkStatus 评估状态 : 送检中/已检验 * @param checkRes 评估结果 : 通过/未通过 * @return 预约列表 */ @GET("check/records/me") Call<ApiResponse<List<JadeModel>>> getMyEvaluationList(@Query("check_status") String checkStatus, @Query("check_res") String checkRes); }

那么我们需要一个储藏室(repository)来进行数据请求以及实现接口回调

If you want to connect to a remote port, you should use the command of

‘netset localhost

release the occupation of port
–>解除端口占用

It’s well known that RecyclerView is a powerful tool to create a list view or a grid view, however, it’s also complicated to use.

There’s a passage I writed a few months ago, in this passage I used an example to show the basic usage of RecyclerView.
—>RecyclerView基础用法

So in my opinion, there are six steps to use RecyclerView.

• Add dependecy of RecyclerView
• Create an activity/fragment, and use the control in it’s layout file.
• Create an item, which is the model of your every list’s view.
• Create a class as a model, which contains the information that is needed in every item.
• Create an adapter.
• Use it in your activity or fragment.

The most important step is step 5, an adapter is so complicated to create. So how can we solve the problem?

There is a princple in Java: High cohesion, low coupling,so we would better to separate the viewHolder from RecyclerViewAdapter
So first, we can create a base adapter.

BaseRecyclerViewAdapter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

public abstract class BaseRecyclerViewAdapter<Data> extends RecyclerView.Adapter<BaseViewHolder> {


    protected List<Data> mDataList;
    protected Context mContext;
    protected LayoutInflater mInflater;
    protected int mItemLayoutId;
    private OnItemClickListener mOnItemClickListener;


    public BaseRecyclerViewAdapter(List<Data> dataList, Context context, @LayoutRes int itemLayoutId) {
        mDataList = dataList;
        mContext = context;
        mInflater = LayoutInflater.from(mContext);
        mItemLayoutId = itemLayoutId;
    }

    @Override
    public void onBindViewHolder(BaseViewHolder holder, final int position) {

        holder.itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                if (mOnItemClickListener != null) {
                    mOnItemClickListener.onItemClick(v, mDataList.get(position), position);
                }

            }
        });
        bindView(holder, mDataList.get(position));
    }


    /**
     * 绑定item中的view和数据
     *
     * @param viewHolder
     * @param item
     */
    protected abstract void bindView(BaseViewHolder viewHolder, Data item);


    @Override
    @SuppressWarnings("unchecked")
    public BaseViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View view = mInflater.inflate(mItemLayoutId, parent, false);
        return new BaseViewHolder(mContext, view);
    }


    @Override
    public int getItemCount() {
        return mDataList.size();
    }

    /**
     * 设置数据
     *
     * @param data 数据
     */
    public void setDataList(Collection<Data> data) {
        this.mDataList.clear();
        this.mDataList.addAll(data);
        notifyDataSetChanged();
    }

    /**
     * 获取当前列表的数据
     */
    public List<Data> getDataList() {
        return this.mDataList;
    }

    /**
     * 添加数据
     *
     * @param data
     */
    public void addItem(Data data) {
        this.mDataList.add(data);
        notifyDataSetChanged();
    }


    /**
     * @param collection
     */
    public void addItems(Collection<Data> collection) {
        this.mDataList.addAll(collection);
        notifyDataSetChanged();
    }


    /**
     * 移除数据
     *
     * @param data 移除的数据
     */
    public void removeItem(Data data) {
        this.mDataList.remove(data);
        notifyDataSetChanged();
    }


    /**
     * 移除数据（带动画）
     *
     * @param position pos
     */
    public void removeItem(int position) {
        this.mDataList.remove(position);
        //该方法不会使position及其之后位置的itemView重新onBindViewHolder
        notifyItemRemoved(position);
        //所以需要从position到列表末尾进行数据刷新
        notifyItemRangeChanged(position, mDataList.size() - position);

    }

    /**
     * 清除全部数据
     */
    public void removeAllItem() {
        mDataList.clear();
        notifyDataSetChanged();
    }

    /**
     * 获取position 处数据
     */
    public Data getItem(int position) {
        return mDataList.get(position);
    }

    /**
     * 刷新页面
     */
    public void refresh() {
        notifyDataSetChanged();
    }

    public void refresh(int position) {
        notifyItemChanged(position);
    }

    public interface OnItemClickListener<Data> {

        /**
         * 点击事件回调
         *
         * @param view
         * @param position
         */
        public void onItemClick(View view, Data data, int position);
    }

    public void setOnItemClickListener(OnItemClickListener onItemClickListener) {
        mOnItemClickListener = onItemClickListener;
    }

}

So We just look at the basic ones.
It’s obviou that in the class we override the three classic methods–onCreateViewHolder(),onBindViewHolder(),getItemCount();
First, we create a ViewHolder

1
2
3
4
5
6

@Override
    @SuppressWarnings("unchecked")
    public BaseViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View view = mInflater.inflate(mItemLayoutId, parent, false);
        return new BaseViewHolder(mContext, view);
    }

Then we will bind the holder to the data

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

@Override
    public void onBindViewHolder(BaseViewHolder holder, final int position) {

        holder.itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                if (mOnItemClickListener != null) {
                    mOnItemClickListener.onItemClick(v, mDataList.get(position), position);
                }

            }
        });
        bindView(holder, mDataList.get(position));
    }

we also set clicklistener to the item
We don’t directly bind the data to the view because we don’t exactly know how many data,how many controls need to be binded, so we should define an abstract method to be override in different situation. That’s why we use the bindView().

So we just need to override two methods–the constuction methond of your class and the bindView() if we want to use it in subclass.

The getItemCount() is so easy that we don’t talk about it.

BaseViewHolder

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

public class BaseViewHolder extends RecyclerView.ViewHolder {


    private final SparseArray<View> mViewSparseArray;
    private Context mContext;
    private View mItemView;


    public BaseViewHolder(Context context, View itemView) {
        super(itemView);
        this.mContext = context;
        mItemView = itemView;
        mViewSparseArray = new SparseArray<>();
    }


    /**
     * 从布局获取泛型view
     *
     * @param viewId
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    protected <T extends View> T findViewById(@IdRes int viewId) {
        //从已经缓存的ViewMap中查找
        View view = mViewSparseArray.get(viewId);
        //如果没有缓存
        if (view == null) {
            //获取实例并加入缓存
            view = mItemView.findViewById(viewId);
            mViewSparseArray.append(viewId, view);
        }
        return (T) view;
    }


    /**
     * 设置TextView类型
     *
     * @param viewId
     * @param value
     * @return
     */
    public BaseViewHolder setText(@IdRes int viewId, @StringRes int value) {
        return setText(viewId, mContext.getString(value));
    }

    public BaseViewHolder setText(@IdRes int viewId, String value) {
        TextView textView = findViewById(viewId);
        textView.setText(value == null ? mContext.getString(R.string.empty) : value);
        return this;
    }


    /**
     * 设置ImageView的url
     *
     * @param viewId
     * @param value
     * @return
     */
    public BaseViewHolder setImgUrl(@IdRes int viewId, String value) {
        ImageView imageView = findViewById(viewId);
        if (value != null) {
            Glide.with(mContext)
                    .load(value)
                    .transition(GenericTransitionOptions.<Drawable>withNoTransition())
                    .into(imageView);
        }
        return this;
    }


    /**
     * 设置ImageView的url
     *
     * @param viewId
     * @return
     */
    public BaseViewHolder setImgRes(@IdRes int viewId, @DrawableRes int drawableId) {
        ImageView imageView = findViewById(viewId);
        imageView.setImageResource(drawableId);
        return this;
    }


    /**
     * 设置控件是否可见
     *
     * @param viewId
     * @param isVisible
     * @return
     */
    public BaseViewHolder setVisible(@IdRes int viewId, boolean isVisible) {
        findViewById(viewId).setVisibility(isVisible ? View.VISIBLE : View.INVISIBLE);
        return this;
    }

    /**
     * 设置控件是否消失(不保留空间)
     *
     * @return
     */
    public BaseViewHolder setGone(@IdRes int viewId) {
        findViewById(viewId).setVisibility(View.GONE);
        return this;
    }

    /**
     * 获取item的View
     *
     * @return
     */
    public View getItemView() {
        return mItemView;
    }

    /**
     * 获取item内部的view
     *
     * @param viewId
     * @return
     */
    public View getViewById(@IdRes int viewId) {
        return findViewById(viewId);
    }


    /**
     * 获取当前viewHolder位置
     *
     * @return
     */
    public int getViewHolderPosition() {
        return getAdapterPosition();
    }


}

The annotate is so clear, from the code of BaseRecyclerViewAdatper we can know that if we want to use the methond bindView(), we should put the parameters of viewHolder which is the type of BaseViewHolder, so in the method, we can use the methods of viewHolder such as setTxt(), setImageRes() to bind the controls the view.

1
2
3
4
5
6
7

/**
    * 绑定item中的view和数据
    *
    * @param viewHolder
    * @param item
    */
   protected abstract void bindView(BaseViewHolder viewHolder, Data item);

So how easy the way to use RecyclerViewAdapter can be if we use the BaseRecyclerViewAdapter? Don’t worry, there is an example

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class CantDoListAdapter extends BaseRecyclerViewAdapter<CalendarModel.BadBean> {
    public CantDoListAdapter(List<CalendarModel.BadBean> badBeanList, Context context, int itemLayoutId) {
        super(badBeanList, context, itemLayoutId);

    }

    @Override
    protected void bindView(BaseViewHolder viewHolder, CalendarModel.BadBean item) {
        viewHolder.setText(R.id.item_calendar_can_do,item.getTitle())
                .setText(R.id.item_calendar_can_do_detail,item.getDescription());
        ImageView imageView = (ImageView)viewHolder.getItemView().findViewById(R.id.item_image_flag);
        imageView.setBackgroundColor(mContext.getResources().getColor(R.color.red));
    }
}

Is so easy, isn’t it?

1. throws & throw
   如果方法声明后有throw语句，则在此方法被调用时，需要在调用方法中用try和catch进行异常捕获，如果不捕获异常，则需要在调用方法中使用throws语句将异常抛出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

import java.util.*;
public class Main {


public static void A(int a)throws Exception,IllegalArgumentException{
if(a == 0) {
throw new Exception("a=0,silly boy!");
}else if(a == 1) {
IllegalArgumentException str=new IllegalArgumentException("a=1, IllegalArgumentException");
throw str;
}
}

public static void main(String[] args) {
int a;
Scanner t = new Scanner(System.in);
try {
a = t.nextInt();
A(a);
}catch(IllegalArgumentException e2) {
System.out.println(e2.toString());
}catch(Exception e){
System.out.println(e.toString());
}

}
}

例如我们在上面的代码里定义了一个A方法，在这个方法里我们用throws声明了可能抛出的异常，然后我们需要在方法体里把异常实例化并且利用throw将其抛出。

在主方法中，我们利用try-catch语句，将可能出现异常的语句用try包括起来，然后利用catch语句来承接这个异常，并且输出异常。

那么接下来就是另外一个问题

2. toString, getMessage, printStackTrace

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

   import java.util.*; public class Main { public static void A(int a)throws Exception,IllegalArgumentException{ if(a == 0) { throw new Exception("a=0,silly boy!"); }else if(a == 1) { IllegalArgumentException str=new IllegalArgumentException("a=1, bitch"); throw str; } } public static void main(String[] args) { int a; Scanner t = new Scanner(System.in); try { a = t.nextInt(); A(a); }catch(IllegalArgumentException e2) { System.out.println(e2.toString()); System.out.println(); System.out.println(e2.getMessage()); System.out.println(); e2.printStackTrace(); }catch(Exception e){ System.out.println(e.toString()); } } }

输入1，结果：

1
2
3
4
5
6
7
8
9
10

java.lang.IllegalArgumentException: a=1, bitch

a=1, bitch

java.lang.IllegalArgumentException: a=1, bitch
at 异常.Main.A(Main.java:10)
at 异常.Main.main(Main.java:20)

`

3. 最后还有一点，子类父类的问题
   子类异常要放在前面，父类异常要写在后面

I think it’s time for me to know what the Tower of Hanoi is and find out how to solve it.

The question:

The problem of the Tower of Hanoi (also known as the Hanoi Tower) is an educational toy derived from an ancient legend of India. When Brahma created the world, he made three diamond pillars, and on a pillar, he smashed 64 gold discs in order of size from bottom to top. Brahma ordered the Brahmin to reposition the discs on the other column in order of size from below. It is also stipulated that the disc cannot be enlarged on the small disc, and only one disc can be moved at a time between the three columns.

Analysis

It’s obviously that we should use the recursive function, but the question is ‘How’?

First, let’s find some laws in the question.Look at the pictures:

• The number of discs is one
  
  

• The number of discs is two

In this part, we use the pillar B as a transformer station, what? transformer station? Don’t worry, We will explain the usage of it.

• The number of discs is three

First we should know our target. We want to move the all pillars to pillar C. It’s obvious that it is impossible to make it at once. So we should find a transformer station. We can move the green one and blue one to pillar B.

So we can use the way in the situation of two discs to move green and blue to B, and then move the red one to C

The last thing we should do is to use the same way of situation of two discs and think pillar A as a transfer station

Code

We have analyze the basic idea of Hanoi, so it is time for us to explore the way to achieve it in code.

As I have said on the begin of the passage, we should use the recursive fuction, because it’s the simplest way to solve the question.

the parameter is four:

• the number of discs
• the pillar that the discs you want to move exist.
• the transfer station
• the target pillar at every step

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void hanoi(int n, char A, char B, char C){
    if(n == 1){
        printf("Move sheet %d from %c to %c\n",n,A,C);
    }else{
        //as we can see, if we want get the result of n,
//we should move n - 1 first, so here we need to
//use the way of recursion

//here we need to move the n - 1 smaller discs from 
//A to B
hanoi(n-1, A,C,B);

//here we move the left biggest one from A to C
printf("Move sheet %d from %c to %c\n",n,A,C);

//here we move the n - 1 samller discs from B to C
hanoi(n-1, B, A, C);
    }
}

Conclusion

If there is any error, please contract with me and teach me how to correct it or I can try my best to correct it myself. I am just a vegetable chicken.

Please bear with me.
o((⊙﹏⊙))o.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

/*
*      
*          ┌─┐       ┌─┐
*       ┌──┘ ┴───────┘ ┴──┐
*       │                 │
*       │       ───       │
*       │  ─┬┘       └┬─  │
*       │                 │
*       │       ─┴─       │
*       │                 │
*       └───┐         ┌───┘
*           │         │
*           │         │
*           │         │
*           │         └──────────────┐
*           │                        │
*           │                        ├─┐
*           │                        ┌─┘    
*           │                        │
*           └─┐  ┐  ┌───────┬──┐  ┌──┘         
*             │ ─┤ ─┤       │ ─┤ ─┤         
*             └──┴──┘       └──┴──┘ 
*                 神兽保佑 
*                 代码无BUG! 
*/

Roliygu is famous because he likes to play games. Today he puts a chessboard in the desktop,and plays a game with Yilan. The size of the chessboard is n by n. A stone is placed in a corner square. They play alternatively with Roliygu having the first move. Each time,player is allowed to move the stone to an unvisited neighbor square horizontally or vertically. The one who can’t make a move will lose the game. If both play perfectly, who will win the game?

Input

The input is a sequence of positive integers each in a separate line. The integers are between 1 and 10 000,inclusive,indicating the size of the chessboard. The end of the input is indicated by a zero.

Output

Output the winner(“Roliygu” or “Yilan”) for each input line except the last zero. No other characters should be inserted in the output.

Analysis

This question is hard if we try to solve it just as the description of the question, however, we can change our mind to think about the question, can we get the result of who will win if we just know the odevity of the grid of the board and the upper-hand player? The anwser is YES!

Let’s look at the two pictures below:

if the grids’ number is even, if obvious that all of the grids and be divided into some pices of 1*2, what is very important for you to know is that the start point is in one grid, so the left grids’ number is actually odd, so you can know that who first, who win;

In the same way we can know that if the grids’ number is odd, the number except the start point will be even, so who later, who win;

So the question has been changed into Jugement of the odevity of the board’s grids number, it’s easy, isn’t it?

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <iostream>
using namespace std;
int main()
{
    int n;
    while(cin>>n)
    {
        if(n == 0)
        {
            break;
        }

        if(n * n % 2 == 0)
        {
            cout<<"Roliygu"<<endl;
        }
        else
        {
            cout<<"Yilan"<<endl;
        }
    }
}

Commit your preferences changes back from this Editor to the SharedPreferences object it is editing. This atomically performs the requested modifications, replacing whatever is currently in the SharedPreferences.
Note that when two editors are modifying preferences at the same time, the last one to call apply wins.
Unlike commit, which writes its preferences out to persistent storage synchronously, apply commits its changes to the in-memory SharedPreferences immediately but starts an asynchronous commit to disk and you won’t be notified of any failures. If another editor on this SharedPreferences does a regular commit while a apply is still outstanding, the commit will block until all async commits are completed as well as the commit itself.
As SharedPreferences instances are singletons within a process, it’s safe to replace any instance of commit with apply if you were already ignoring the return value.
You don’t need to worry about Android component lifecycles and their interaction with apply() writing to disk. The framework makes sure in-flight disk writes from apply() complete before switching states.
The SharedPreferences.Editor interface isn’t expected to be implemented directly. However, if you previously did implement it and are now getting errors about missing apply(), you can simply call commit from apply().

这两个方法的区别在于：

1. apply没有返回值而commit返回boolean表明修改是否提交成功
2. apply是将修改数据原子提交到内存, 而后异步真正提交到硬件磁盘, 而commit是同步的提交到硬件磁盘，因此，在多个并发的提交commit的时候，他们会等待正在处理的commit保存到磁盘后在操作，从而降低了效率。而apply只是原子的提交到内容，后面有调用apply的函数的将会直接覆盖前面的内存数据，这样从一定程度上提高了很多效率。
3. apply方法不会提示任何失败的提示。
   由于在一个进程中，sharedPreference是单实例，一般不会出现并发冲突，如果对提交的结果不关心的话，建议使用apply，当然需要确保提交成功且有后续操作的话，还是需要用commit的。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2],

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。

你不需要考虑数组中超出新长度后面的元素。

示例 2:

给定 nums = [0,0,1,1,1,2,2,3,3,4],

函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。

你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以“引用”方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

1
2
3
4
5
6
7
8
9

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

Java代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Solution {
    public int removeDuplicates(int[] nums) {
        if( nums.length == 0){
            return 0;
        }
        int i = 0;
        for( int j = 1; j < nums.length; j++){
            if( nums[j] != nums[i] ){
                i++;
                nums[i] = nums[j];
            }
        }
        return i+1;
    }
}

我们以一个整型数组为例

1 2 2 3 4

传入的为数组的引用，所以更改对用户是可见的

• 如果长度为零，直接返回零
• 如果不为零，i = 0；进入循环 j = 1;
  • nums[j] = 2,nums[j] != nums[i]
    • i++ 变成了1；
    • nums[i] = nums[j] = 2;

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

（友情链接 —>Java数据结构和算法（七）——链表 )

首先先看看怎么做这道题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l2 == null){
            return l1;
        }
        if(l1 == null){
            return l2;
        }
        
        ListNode temp;
        
        
            if (l1.val < l2.val){
                temp = l1;
                temp.next = mergeTwoLists(l1.next,l2);
            }else{
                temp = l2;
                temp.next = mergeTwoLists(l1,l2.next);
            }
      
        
        return temp;
    
    }
}

首先我们要知道Java链表是个啥玩意，先看个实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

import javax.xml.soap.Node;

public class SingleLinkedList {

private int size;
private Node head;

public SingleLinkedList() {
size = 0;
head = null;
}

//链表的每个节点类
private class Node{
private Object data;
private Node next;

public Node(Object data) {
this.data = data;
}
}

//在链表头添加元素
public Object addHead(Object obj) {
Node newHead = new Node(obj);
if(size == 0) {
head = newHead;
}else {
newHead.next = head;
head = newHead;
}
size++;
return obj;
}

//在链表头删除元素
public Object deleteHead() {
Object obj = head.data;
head = head.next;
size--;
return obj;
}

//查找指定元素，找到了返回Node,找不到返回null
public Node find(Object obj) {
Node current = head;
int tempSize = size;
while(tempSize > 0) {
if (obj.equals(current.data)) {
return current;
}else {
current = current.next;
}
tempSize--;
}
return null;
}

//删除指定的元素，删除成功返回true
public boolean delete(Object value) {
if(size == 0) {
return false;
}

Node current = head;
Node previous = head;
while(current.data != value) {
if(current.next == null) {
return false;
}else {
previous = current;
current = current.next;
}
}

if(current == head) {
head = current.next;
size--;
}else {
previous.next = current.next;
size--;
}

return true;

}

//判断链表是否为空
public boolean isEmpty() {
return (size == 0);
}

//显示节点信息
public void display() {
if (size > 0) {
Node node = head;
int tempSize = size;
if(tempSize == 1) {//当前链表只有一个节点
System.out.println("["+node.data+"]");
return;
}
while(tempSize > 0) {
if(node.equals(head)) {
    System.out.print("["+node.data+"->");
}else if(node.next == null) {
System.out.print(node.data+"]");
}else {
System.out.print(node.data+"->");
}
node = node.next;
tempSize--;
}
System.out.println();
}else {
System.out.println("[]");
}
}

}

定义

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。
　　使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。

单链表(我这种菜鸡只能谈论这种最简单的链表了)

单链表是链表中结构最简单的。一个单链表的节点(Node)分为两个部分，第一个部分(data)保存或者显示关于节点的信息，另一个部分存储下一个节点的地址。最后一个节点存储地址的部分指向空值。
　　单向链表只可向一个方向遍历，一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。而插入一个节点，对于单向链表，我们只提供在链表头插入，只需要将当前插入的节点设置为头节点，next指向原头节点即可。删除一个节点，我们将该节点的上一个节点的next指向该节点的下一个节点。

关于本题

那么结合本题，我们可以从题意中得知，要把valu小的放在前。

• 第一步，传进两个链表
• 第二步，判断哪个是空，一个空，返回另一个
• 第三步，声明一个新的链表temp作为中间链表
  • 如果l1.valu < l2.valu
    • temp = l1
    • temp.next的地址则需要通过递归进行新一轮的比较，所以temp.next = mergeTowLists(l1.next, l2)
      ……
  • else
    • temp = l2
    • temp.next的地址则需要通过递归进行新一轮的比较，So, temp.next = mergeTowLists(l1, l2.next)
      ……
• 第四步，以上递归进行完了，就可以将最终的temp返回了。

示例 1:
输入: [“flower”,”flow”,”flight”]
输出: “fl”

示例 2:
输入: [“dog”,”racecar”,”car”]
输出: “”
解释: 输入不存在公共前缀。

Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Solution{
    public String maxCommon(String[] s){
        if ( s.length == 0 ){
            return "";
        }
        String len = s[0];
        for ( int i = 1; i < s.length; i++){
           while( s[i].indexOf(len) != 0 ){
                len = len.substring(0, len.length() - 1);
                if(len.isEmpty()){
                    return "";
                }
            }
        }
        return len;
    }
}

先看看是不是空的

如果s根本就没有任何数据，那还判断毛线？直接返回个空字符串就行了呗；

找一个串当基础

反正是找公共前缀，那么这个公共前缀一定存在于每个串中。那么我就拿第一个字符串s[0]当一个基础，声明一个字符串len,等于s[0];

循环判断

从第二个字符串开始，进行判断。利用indesOf()方法，看看len是不是在s[i]字符串中并且是不是从0下标开始的。

• 如果是，终止while循环
• 如果不是，那就让len减去最后一个字符，继续循环。
  • 如果一直循环到len人家一点不剩了，s[i]里面还是没有跟它一致的，那凉了，这几个字符串没有公共前缀。返回空字符串。

    一直循环下去

    最后返回len就可以了。