leetcode 天池X LeetCode

leetcode 算法天池举办，菜鸡总结一下吧。

221021天池-02. 光线反射

这道题还是比较简单的，直接就是一个暴搜。会有下面的性质方便编码，假设当前的位置是(x, y) , x增量和y的增量是(dirx, diry)：

• 如果是L镜子，那么会把原来的增量改变为(diry, dirx), 并且移动到(x + diry, y + dirx)的格子。
• 如果是R镜子，那么会把原来的增量改变为(-diry, -dirx), 并且移动到(x - diry, y - dirx)的格子。
• 否则，增量不变，移动到(x + dirx, y + diry)的格子。

也就是说，这里的增量可以表示一种朝向，初始增量为(1, 0)，表示朝下走。碰见左镜子，增量为(0, 1)，就变成朝右走了。同理如果朝上走的光为(-1, 0)， 碰见左镜子，就会向左走(0, -1)。也就是增量为(0, -1)。这样可以总结为上面的规律。

代码就很简单了。

class Solution {
public:
    int n, m;
    vector<string>grid;
    int dfs(int dirx, int diry, int x, int y) {
        if (x < 0 || x == n || y < 0 || y == m) {
            return 0;
        }
        if (grid[x][y] == 'L') {
            return dfs(diry, dirx, x + diry, y + dirx) + 1;
        } else if (grid[x][y] == 'R') {
            return dfs(-diry, -dirx, x - diry, y - dirx) + 1;
        } else {
            return dfs(dirx, diry, x + dirx, y + diry) + 1; 
        }
    }
    int getLength(vector<string>& grid) {
        n = grid.size(), m = grid[0].size();
        this->grid = grid;
        return dfs(1, 0, 0, 0);
    }
};

[221021天池-03. 整理书架](221021天池-03. 整理书架)

题目很简单，但是我没想到，以为是子序列的题目，最后发现是单调栈。忏愧，学的还是不扎实。

字典序最小，那么如果前面的比后面的大，前面的还能仍的话，就可以直接丢弃了。这样字典序是最小的。

实现方面的话，需要统计每一个字符还剩下多少，还有就是需要统计每一个字符在栈里有多少，如果大于等于limit了，就直接扔掉就行了。

class Solution {
public:        
   
    vector<int> arrangeBookshelf(vector<int>& order, int limit) {
        unordered_map<int, int>left;                // 总共剩下的数量，也就是总的减去 丢掉 的。
        int n = order.size();
        for (int x : order) {
            left[x]++;
        }
        stack<int>s;
        unordered_map<int, int>inS;
        for (int x: order) {
            if (inS[x] == limit) {
                left[x]--;
                continue;
            }
            while(!s.empty() && s.top() > x && left[s.top()] > limit) { // 栈顶元素大直接删除，但是需要足够数量
                left[s.top()]--;
                inS[s.top()]--;
                s.pop();
            }
            s.push(x);
            inS[x]++;
        }
        vector<int>ans;
        while (!s.empty()) {ans.push_back(s.top()); s.pop(); }
        reverse(ans.begin(), ans.end());
        return ans;
    }
};

221021天池-04. 意外惊喜

初始一看以为是分组背包问题，高兴了一下，结果写完代码，直接tle。真的是意外惊喜，还是两个意外惊喜。这个和2218. 从栈中取出 K 个硬币的最大面值和题目很类似，但是数据量比他大，并且多了一个递增的条件。就不能使用分组背包的代码了。

先放上代码，题解明天在写吧。

package main

// https://space.bilibili.com/206214
func brilliantSurprise(a [][]int, lim int) (ans int) {
	dp := make([]int, lim+1)
	var f func([][]int, []int)
	f = func(a [][]int, tot []int) {
		if len(a) == 1 {
			s := 0
			for i, v := range a[0] {
				if i >= lim {
					break
				}
				s += v
				ans = max(ans, dp[lim-(i+1)]+s)
			}
			return
		}

		tmp := append([]int{}, dp...)

		m := len(a) / 2
		for i, r := range a[:m] {
			for j := lim; j >= len(r); j-- {
				dp[j] = max(dp[j], dp[j-len(r)]+tot[i])
			}
		}
		f(a[m:], tot[m:])

		dp = tmp
		for i, r := range a[m:] {
			for j := lim; j >= len(r); j-- {
				dp[j] = max(dp[j], dp[j-len(r)]+tot[m+i])
			}
		}
		f(a[:m], tot[:m])
	}

	tot := make([]int, len(a))
	for i, r := range a {
		for _, v := range r {
			tot[i] += v
		}
	}
	f(a, tot)
	return
}

func max(a, b int) int {
	if b > a {
		return b
	}
	return a
}