发表于 | 阅读次数:
字数统计: 0 | 阅读时长 ≈ 1

发表于 | 阅读次数:
字数统计: 84 | 阅读时长 ≈ 1 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Solution {
public:
    double champagneTower(int poured, int query_row, int query_glass) {
        double result[101][101] = {0.0};
        result[0][0] = poured;
        for (int i = 0; i < 100; i++) {
            for (int j = 0; j <= i; j++) {
                if (result[i][j] >= 1) {
                    result[i + 1][j] += (result[i][j] - 1) / 2.0;
                    result[i + 1][j + 1] += (result[i][j] - 1) / 2.0;
                    result[i][j] = 1;
                }
            }
        }
        return result[query_row][query_glass];
    }
};

发表于 | 阅读次数:
字数统计: 53 | 阅读时长 ≈ 1 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Solution(object):
    def bestRotation(self, A):
        """
        :type A: List[int]
        :rtype: int
        """
        N = len(A)
        change = [1] * N
        for i in xrange(N): 
            change[(i - A[i] + 1) % N] -= 1
        for i in xrange(1, N): 
            change[i] += change[i - 1]
        return change.index(max(change))

发表于 | 分类于 | 阅读次数:
字数统计: 95 | 阅读时长 ≈ 1 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Solution {
public:
    void dfs(vector<vector<int>>& g, vector<vector<int>>& res, vector<int> path, int cur) {
        path.push_back(cur);
        if (cur == g.size() - 1) res.push_back(path);
        else for (auto it: g[cur]) dfs(g, res, path, it);
    }
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& g) {
        vector<vector<int>> paths;
        vector<int> path;
        dfs(g, paths, path, 0);
        return paths;
    }
};

发表于 | 分类于 | 阅读次数:
字数统计: 87 | 阅读时长 ≈ 1

深度优先搜索 更符合计算机的习惯

也就是一般使用栈来处理问题(递归)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Solution(object):
    def levelOrder(self, root):
        if not root:
            return []
        self.result = []
        self._dfs(root, 0)
        return self.result

    def _dfs(self, node, level):
        if not node: return

        if len(self.result) < level + 1:
            self.result.append([])

        self.result[level].append(node.val)

        self._dfs(node.left, level+1)
        self._dfs(node.right, level+1)