这题挺常规的,首先考虑如果要停留在i个位置,那么它的上一步必然只有三个选择:
- 就在i位置(呆在原位)
- 在i-1位置(向右一步)
- 在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];
}
}
实现反转,有两种思路
- 递归:从链表末端开始,将末端结点的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;
}
}
- 迭代:迭代就是从头开始,因为从头开始处理方式中间过程必然会产生断链,需要维护两个结点,一个是当前处理结点,一个是当前处理结点的前一个结点(原始顺序的父结点)。
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;
}
}