796
简单的字符串操作
797
深度优先搜索
非常简洁的实现，还是要学习的
简洁之处：
没有使用我全局定义的 ans
和 path
ans 和path 在这种情境下被统一起来，最终也没有进行回退，每一次都是新的拷贝创建
class Solution(object):
def allPathsSourceTarget(self, graph):
N = len(graph)
def solve(node):
if node == N-1: return [[N-1]]
ans = []
for nei in graph[node]:
for path in solve(nei):
ans.append([node] + path)
return ans
return solve(0)
798
最小旋转最大得分
计算初始分数，在每个旋转点时的得分和失分
如果直接（对于每一个位置算一边，但是注意到相邻的位置实际上大量的重复）进行统计比较麻烦的话，采取这种算边际损失量的方法不失为一种好方法
class Solution {
private:
int n;
int in[20001];
int out[20001];
void pro(int k,int i){
if(k>i){
in[i+1]++;
out[i+n-k+1]++;
}else {
in[i+1]++;
out[i-k+1]++;
}
}
public:
int bestRotation(vector<int>& A) {
memset(in,0,sizeof(in));
memset(out,0,sizeof(out));
n=A.size();
for(int i=0;i<n;i++){
pro(A[i],i);
}
int s=0;
int bests=-1;
int besti=-1;
// int besti=0;
for(int i=0;i<n;i++){
if(A[i]<=i){
s++;
}
}
if(bests<s){
bests=s;
besti=0;
}
for(int i=1;i<n;i++){
s+=in[i];
s-=out[i];
if(bests<s){
bests=s;
besti=i;
}
}
return besti;
}
};
附 我的naive 思路没有问题 但是有更好的解决方法
五行解决问题
int bestRotation(vector<int>& A) {
int N = A.size();
int change[N] = {0};
for (int i = 0; i < N; ++i) change[(i - A[i] + 1 + N) % N] -= 1;
for (int i = 1; i < N; ++i) change[i] += change[i - 1] + 1;
return distance(change, max_element(change, change + N));
}
我还是有几个关键的点没有观察到
- k++时会且仅会多得一分
- 而且减分的时候 都是index 和 value 的差值加1 最后取正模就好
- 不用计算初始的分值，只用计算中途
- 加分过程与累计合并，简化代码
- 累积起来以后用 max_element得到最大一个只对应的迭代器，使用distance 得到迭代器 也就是需要的代码
java
public int bestRotation(int[] A) {
int N = A.length;
int change[] = new int[N];
for (int i = 0; i < N; ++i) change[(i - A[i] + 1 + N) % N] -= 1;
int max_i = 0;
for (int i = 1; i < N; ++i) {
change[i] += change[i - 1] + 1;
max_i = change[i] > change[max_i] ? i : max_i;
}
return max_i;
}
python
def bestRotation(self, A):
N = len(A)
change = [1] * N
for i in range(N): change[(i - A[i] + 1) % N] -= 1
for i in range(1, N): change[i] += change[i - 1]
return change.index(max(change))
python中 [1] *N 的用法也是我不会的。(批量初始化
799
倒水，但是考虑问题的时候总是想递归的进行，跟随时间进行，
实际上没有必要，直接按照总量的水溢出问题就会简单许多，问题虽然是和时间高度相关的，但是最后的问题所在没有与时间相关，于是可以直接计算终态
class Solution {
private:
double w[102][102];
public:
double champagneTower(int poured, int query_row, int query_glass) {
memset(w,0,sizeof(w));
w[0][0]=poured;
bool flag=true;
int row=0;
double ans=0;
while(flag){
if(row==query_row){
ans=w[row][query_glass];
break;
}
flag=false;
for(int i=0;i<=row;i++){
if(w[row][i]>1){
w[row+1][i]+=(w[row][i]-1)/2;
w[row+1][1+i]+=(w[row][i]-1)/2;
flag=true;
}
}
row++;
}
return ans>1?1:ans;
}
};
Python的快速解决方案
class Solution(object):
def champagneTower(self, poured, query_row, query_glass):
A = [[0] * k for k in xrange(1, 102)]
A[0][0] = poured
for r in xrange(query_row + 1):
for c in xrange(r+1):
q = (A[r][c] - 1.0) / 2.0
if q > 0:
A[r+1][c] += q
A[r+1][c+1] += q
return min(1, A[query_row][query_glass])
