LeetCode停在原地的方案数（动态规划）,反转链表

这题挺常规的，首先考虑如果要停留在i个位置，那么它的上一步必然只有三个选择：

1. 就在i位置（呆在原位）
2. 在i-1位置（向右一步）
3. 在i+1位置（向左一步）
   然后我们需要求得steps步在0位置的，就至少需要求得在steps-1在0，1位置的、steps-2 0，1，2位置…
   不过在只有1步的范围，能达到的位置也只有1位置。如下图所示
   没有填充的都是0.
   dp[i][j]数组的含义自然就是在i步到达j位置有多少种方案
   转移方程：dp[i][j] = dp[i-1][j]+dp[i-1][j-1]+dp[i][j+1];//注意0位置和arrleng
   初始化：就是步数为1时，将0，1位置置于1.

优化：从转移方程可以看出，于我们有用的只有上一步的方法数，所以我们可以将数组长度改为[2][arrleng].只需要在在偶数步数时，上次存于1位置，奇数步时，上次存于0位置。（因为不优化内存超限制了…所以…）

class Solution {
   public static int numWays(int steps, int arrLen) {
        int mod = 1000000000+7;
        int[][] dp = new int[2][arrLen];
        dp[0][1] = 1;dp[0][0] = 1;//初始化
        for(int i=1;i<steps;i++){
            int inx = (i+1)&1;
            int iinx = inx==0?1:0;
            for(int j=0;j<=i+1&&j<arrLen;j++){

                dp[iinx][j] = (((j==0?0:(dp[inx][j-1]%mod))+
                        (j==arrLen-1?0:(dp[inx][j+1]%mod)))%mod+(dp[inx][j]%mod))%mod;
            }
        }
        return dp[(steps+1)&1][0];
    }
}

实现反转，有两种思路

1. 递归：从链表末端开始，将末端结点的next指向前一个，再将前一个指向它的断开，一直类推，直到到首端。记得保存末端结点的位置。

class Solution {
    ListNode hh;
    public ListNode reverseList(ListNode head){
        reverseList1(head);
        return hh;
    }
    private ListNode reverseList1(ListNode head) {
            if(head==null||head.next==null){
                hh = head;
                return head;
            }
            ListNode ln = reverseList1(head.next);
            ln.next = head;
            head.next = null;
            return head;
             
    }
}

2. 迭代：迭代就是从头开始，因为从头开始处理方式中间过程必然会产生断链，需要维护两个结点，一个是当前处理结点，一个是当前处理结点的前一个结点（原始顺序的父结点）。
   

class Solution {

    public ListNode reverseList(ListNode head){
       ListNode pre = null;
       ListNode crr = head;
       while(crr!=null){
           ListNode temp = crr.next;
           crr.next = pre;
           pre = crr;
           crr = temp;
       }
       return pre;
    }
}