leetcode 75

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])