图论——leetcode
851. 喧闹和富有 - 力扣（LeetCode）
复习一下链式前向星
注意题目要求的是拓扑序严格大于的数，这个时候按顺序统计的拓扑序并不是严格大于的关系，因此要在拓扑图中不断更新
class Solution {
const static int N = 510 * 510;
public:
int ne[N], idx, h[N], e[N], ind[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
vector<int> loudAndRich(vector<vector<int>>& richer, vector<int>& quiet) {
//更有钱且最安静的人
//寻找拓扑序，然后找到更安静的人
//b ---> a
idx = 0;
memset(h, -1, sizeof h);
int n = quiet.size();
for(int i = 0; i < richer.size(); i ++ )
{
int a = richer[i][0], b = richer[i][1];
add(a, b);//a到b的一条边
ind[b] ++;
}
vector<int> ans(n);
queue<int> q;
for(int i = 0; i < n; i ++ )
{
if(!ind[i]) q.push(i);
ans[i] = i;//初始答案
}
while(q.size())
{
int u = q.front();
q.pop();
for(int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];//u比j更有钱
ind[j] --;
if(quiet[ans[j]] > quiet[ans[u]])//u更加安静
ans[j] = ans[u];
if(!ind[j]) q.push(j);
}
}
return ans;
}
};
搜索版本，对每个点搜索拓扑序比他大的点，更新最小quiet
class Solution {
public:
vector<int> loudAndRich(vector<vector<int>> &richer, vector<int> &quiet) {
int n = quiet.size();
vector<vector<int>> g(n);
for (auto &r : richer) {
g[r[1]].emplace_back(r[0]);
}
vector<int> ans(n, -1);
function<void(int)> dfs = [&](int x) {
if (ans[x] != -1) {
return;
}
ans[x] = x;
for (int y : g[x]) {
dfs(y);
if (quiet[ans[y]] < quiet[ans[x]]) {
ans[x] = ans[y];
}
}
};
for (int i = 0; i < n; ++i) {
dfs(i);
}
return ans;
}
};
310. 最小高度树 - 力扣（LeetCode）
对于无向图，如何进行拓扑排序，可以设置入度最小为1，这时拓扑序是外层小于内层。
class Solution {
public:
vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
//最大值最小
//删除叶子节点,最终会剩下一个点或者两个点，如果有第三个点，那么可以删除
vector<int> g[n];
vector<int> ind(n);
for(int i = 0; i < n - 1; i ++ )
{
g[edges[i][0]].push_back(edges[i][1]);
g[edges[i][1]].push_back(edges[i][0]);
ind[edges[i][0]] ++;
ind[edges[i][1]] ++;
}
queue<int> q;
vector<bool> st(n);
vector<int> dist(n);
int cnt = 0;
for(int i = 0; i < n; i ++ )
{
if(ind[i] == 1)
{
q.push(i);
dist[i] = 0;
}
}
while(n - (cnt ++) > 2)//最终会剩余两个或者一个，这时到达了最内层
{
int u = q.front();
q.pop();
st[u] = true; // 删除
for(int i = 0; i < g[u].size(); i ++ )
{
int j = g[u][i];
if(!st[j])//为了防止反复，经过的不会再经过
{
dist[j] = max(dist[j], dist[u] + 1);
if(-- ind[j] == 1) q.push(j);
}
}
}
int res = *max_element(dist.begin(), dist.end());
vector<int> ans;
for(int i = 0; i < n; i ++ )
if(dist[i] == res) ans.push_back(i);
return ans;
}
};
802. 找到最终的安全状态 - 力扣（LeetCode）
反向建图 + 拓扑排序
一个节点不会进入环则是安全的，正向无法保证这个点的入度为0，反向建图，从终点开始拓扑排序，找到所有满足要求的点
class Solution {
public:
vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
//找到拓扑图的所有点
int n = graph.size();
vector<int> ind(n);
vector<int> g[n];
for(int i = 0; i < n; i ++ )
{
for(int j = 0; j < graph[i].size(); j ++ )
{
ind[i] ++;
g[graph[i][j]].push_back(i);//反向边
}
}
vector<int> ans;
queue<int> q;
for(int i = 0; i < n; i ++ )
{
if(!ind[i])
{
q.push(i);
}
}
while(q.size())
{
auto u = q.front();
q.pop();
ans.push_back(u);
for(int i = 0; i < g[u].size(); i ++ )
{
int j = g[u][i];
ind[j] --;
if(!ind[j]) q.push(j);
}
}
sort(ans.begin(), ans.end());
return ans;
}
};
407. 接雨水 II - 力扣（LeetCode）
该点的盛的雨水取决于周围边界的最小值，最短路的思路，从外圈最小高度不断扩展，
class Solution {
public:
typedef pair<int, pair<int,int>> PIII;
priority_queue<PIII, vector<PIII>, greater<PIII>> q;
bool st[201][201];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int trapRainWater(vector<vector<int>>& heightMap) {
int n = heightMap.size(), m = heightMap[0].size();
int ans = 0;
for(int i = 0; i < n; i ++ ){
for(int j = 0; j < m; j ++ ){
if(i == 0 || i == n - 1 || j == 0 || j == m - 1){
q.push({heightMap[i][j], {i, j}});
st[i][j] = true;
}
}
}
while(q.size()){
auto t = q.top();
int h = t.first, x = t.second.first, y = t.second.second;
q.pop();
for(int i = 0; i < 4; i ++ ){
int nx = dx[i] + x, ny = dy[i] + y;
if(nx < 0 || ny < 0 || nx >= n || ny >= m || st[nx][ny]) continue;
if(heightMap[nx][ny] < h){
ans += h - heightMap[nx][ny];
}
st[nx][ny] = true;
q.push({max(heightMap[nx][ny], h), {nx, ny}});
}
}
return ans;
}
};
并查集的思路：
由于数值的范围在20000以内，可以用并查集搞。
把要流出去的点和n * m相连。从0到最高点，依次考虑每个高度。
假设当前考虑到高度为v的方块，枚举所有高度为v的方块，计算有多少个v的块可以填一个高度的水。
由于所以低于这个方块的都已经考虑过，直接看周围是否有已经vis过的方块，然后把他们和当前块连起来，表示往当前块上放水会流向这些块。
对于这一层的答案，就是高度为v的块 - 要流出去的块。
详细来说 对于给定高度v的块，我们给遍历到的全部格子加上v+1的水量，因为高于v的格子不会有水的增加，检查四周的格子是否遍历过，如果这个格子已经是边界，那么表示增加的水会流出来，如果四周是遍历过表示水会从这个格子流向四周这些格子，如果这些格子有流向边界的，那么这些格子的水都会流出边界。最终对于每个水位增加的水量为cnt - sz[find(n*m)],这是遍历到的格子增加水量，但是有的格子会从边界流出，边界点为n * m
class Solution {
public:
int f[220 * 220], vis[220 * 220], sz[220 * 220];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int n, m;
int find(int x )
{
if(f[x] == x) return x;
return f[x] = find(f[x]);
}
bool check(int x, int y)
{
if(x < 0 || x >= n || y < 0 || y >= m) return 0;
return 1;
}
int trapRainWater(vector<vector<int>>& heightMap) {
n = heightMap.size(), m = heightMap[0].size();
for(int i = 0; i <= n * m; i ++ ) f[i] = i, sz[i] = 1;
sz[n * m] = 0;
int V = 0;
vector<int> hp[20010];
for(int i = 0; i < n; i ++ )
for(int j = 0; j < m; j ++ )
{
hp[heightMap[i][j]].push_back(i * m + j);
V = max(heightMap[i][j], V);
}
int cnt = 0, res = 0;
for(int v = 0; v < V; v ++ )
{
for(int i = 0; i < hp[v].size(); i ++ )
{
cnt ++;
int x = hp[v][i] / m, y = hp[v][i] % m;
vis[x * m + y] = 1;
for(int k = 0; k < 4; k ++ )
{
int nx = x + dx[k], ny = y + dy[k];
int flag = 0;
if(!check(nx, ny) || vis[nx * m + ny]) //四周有处理过或者是边界
{
int fx, fy;
if(!check(nx, ny)) fx = find(n * m);
else fx = find(nx * m + ny);
fy = find(x * m + y);
if(fx == fy) continue;
sz[fx] += sz[fy];
f[fy] = fx;
}
}
}
cout << cnt << " " << sz[find(n * m)] << endl;
res += cnt - sz[find(n * m)];
}
return res;
}
};
1631. 最小体力消耗路径 - 力扣（LeetCode）
我使用了prim算法，这样不用建立并查集，但是因为不是稠密图，所以效率不高
class Solution {
public:
int dist[10010];
int st[10010];
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
int minimumEffortPath(vector<vector<int>>& heights) {
//找到一条路径，它的高度差最大值最小
//二分答案，找到合适的dfs路径
//对于所有的边，从小到大，并查集直到两个点相连。
//从左上角开始，每次寻找离自己这个集合最近的一个点，
int n = heights.size(), m = heights[0].size();
int ans = 0;
memset(dist, 0x3f, sizeof(dist));
dist[0] = 0;
for(int i = 1; i <= n * m; i ++ )//最多需要加入nm个点
{
int t = -1;
for(int j = 0; j < n * m; j ++ )
{
if(!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
}
ans = max(ans, dist[t]);//记录所有加入的点的最大路径值
st[t] = true;
if(t == n * m - 1) break;
int x = t / m, y = t % m;//这个点是要加入的点
for(int j = 0; j < 4; j ++ )//更新一下周围的点
{
int nx = x + dx[j], ny = y + dy[j];
if(nx < 0 || ny < 0 || nx >= n || ny >= m) continue;
dist[nx * m + ny] = min(dist[nx * m + ny], abs(heights[nx][ny] - heights[x][y]));
}
}
return ans;
}
};
778. 水位上升的泳池中游泳 - 力扣（LeetCode）
堆+广度优先搜索，从最小的dep寻找是否能到达四周的游泳池，类似于dijkstra算法
class Solution {
public:
typedef pair<int,int> PII;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int swimInWater(vector<vector<int>>& grid) {
//深度优先搜索
int n = grid.size(), m = grid[0].size();// x * m + y
priority_queue <PII, vector<PII>, greater<PII> > q;
vector<int> st(m * n);
q.push({grid[0][0], 0});
st[0] = true;
int ans;
int cnt = 0;
while(!q.empty())
{
cnt ++;
auto t = q.top();
q.pop();
int dep = t.first, u = t.second;
if(u == m * n - 1)
{
ans = dep;
break;
}
for(int i = 0; i < 4; i ++ )
{
int nx = dx[i] + u / m;
int ny = dy[i] + u % m;
if(nx < 0 || ny < 0 || nx >= n || ny >= m) continue;
if(st[nx * m + ny]) continue;//只会入队一次
q.push({max(dep, grid[nx][ny]), nx * m + ny});
st[nx * m + ny] = true;
}
}
return ans;
}
};
从小到大，如果四周有比它小的那就是可以游到，知道可以游到终点。
class Solution {
public:
int f[2510];
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int find(int x)
{
if(f[x] == x) return x;
return f[x] = find(f[x]);
}
int swimInWater(vector<vector<int>>& grid) {
//从最小的开始，每次将这个点和周围比他小的点连接起来,直到起点和终点连接起来了
vector<pair<int, int>> nums;
int n = grid.size();
for(int i = 0; i < n * n; i ++ ) f[i] = i;
for(int i = 0; i < n; i ++ )
for(int j = 0; j < n; j ++ )
{
nums.push_back({grid[i][j], i * n + j});
}
sort(nums.begin(), nums.end());//从小到大
int ans;
for(int i = 0; i < nums.size(); i ++ )
{
int dep = nums[i].first, u = nums[i].second;
int a = find(u);
for(int j = 0; j < 4; j ++ )
{
int nx = dx[j] + u / n;
int ny = dy[j] + u % n;
if(nx < 0 || ny < 0 || nx >= n || ny >= n) continue;
if(dep > grid[nx][ny])
{
int b = find(nx * n + ny);
f[b] = a;
}
}
if(find(0) == find(n * n - 1))
{
ans = dep;
break;
}
}
return ans;
}
};
743. 网络延迟时间 - 力扣（LeetCode）
最短路问题
class Solution {
public:
int dist[110][110];
int networkDelayTime(vector<vector<int>>& times, int n, int k) {
//k -- 所有
memset(dist, 0x3f, sizeof(dist));
for(int i = 0; i < times.size(); i ++)
{
int u = times[i][0], to = times[i][1], w = times[i][2];
dist[u][to] = w;
}
for(int k = 1; k <= n; k ++ )
for(int i = 1; i <= n; i ++ )
for(int j = 1; j <= n; j ++ )
{
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
int ans = 0;
dist[k][k] = 0;
for(int i = 1; i <= n; i ++ )
{
ans = max(ans, dist[k][i]);
}
if(ans == 0x3f3f3f3f) return -1;
return ans;
}
};
787. K 站中转内最便宜的航班 - 力扣（LeetCode）
裂开解法
可知Floyd算法是经过中转以后的最短路求解。那么可以算出1、3、7、15、31等次中转的最短路，这样得到k次的最短路就是答案。
注意点：
- 中转一次的答案不能直接更新到a上，需要一个中间数组temp。
- 每次dp2记录的是更新
(2n + 1)次中转的结果，也就是0，1，3，7，15，31，所以k&1时还要再算一步
class Solution {
public:
int dp[200][200];
int dp2[200][200];
int n;
int findCheapestPrice(int _n, vector<vector<int>>& flights, int src, int dst, int K) {
n = _n;
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
{
if(i != j)
dp[i][j] = 1e9;
}
for(int i = 0; i < flights.size(); i ++)
{
int x = flights[i][0], y = flights[i][1], w = flights[i][2];
dp[x][y] = min(dp[x][y], w);
}
memcpy(dp2, dp, sizeof(dp));
while(K)//快速幂求出经过k次中转的最短路
{
if(K & 1) qsm(dp, dp2);
qsm(dp2, dp2);
K >>= 1;
}
return dp[src][dst] == 1e9 ? -1: dp[src][dst];
}
void qsm(int a[][200], int b[][200])//a不知道中转了几次，b不知道中转了几次，总共中转了加起来
{
static int temp[200][200];
memset(temp, 0x3f, sizeof(temp));
for(int m = 0; m < n; m++)
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
{
if(a[i][m] + b[m][j] <= a[i][j])//小于等于可以围着自己中转
{
temp[i][j] = min(temp[i][j], a[i][m] + b[m][j]);
}
}
memcpy(a, temp, sizeof(temp));//指定的大小是temp的大小
}
};
这样算出的结果是所有点对的最短路，但是题目要求只要源节点到目的节点的最短路，这样的话不用枚举起点的终点，只要bellman算法松弛k + 1次即可
class Solution {
public:
int dist[200][200];
int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
memset(dist, 0x3f, sizeof dist);
dist[0][src] = 0;
for(int i = 1; i <= k + 1; i ++ )
{
for(auto &t : flights)
{
dist[i][t[1]] = min({dist[i][t[1]], dist[i - 1][t[1]], dist[i - 1][t[0]] + t[2]});
}
}
return dist[k + 1][dst] == 0x3f3f3f3f ? -1 : dist[k + 1][dst];
}
};
1786. 从第一个节点出发到最后一个节点的受限路径数 - 力扣（LeetCode）
class Solution {
public:
const int mod = 1e9 + 7;
typedef pair<int, int> PII;
int countRestrictedPaths(int n, vector<vector<int>>& edges) {
vector<vector<PII>> g(n + 1);
for(auto &e :edges)
{
int u = e[0], v = e[1], d = e[2];
g[u].push_back({v, d});
g[v].push_back({u, d});
}
priority_queue<PII, vector<PII>, greater<PII>> q;
vector<int> dist(n + 1, INT_MAX);
dist[n] = 0;
vector<bool> vis(n + 1, false);
q.push({0, n});
while(!q.empty())
{
auto [dis, to] = q.top();
q.pop();
if(vis[to]) continue;
vis[to] = true;
for(auto [x, w] : g[to])
{
if(dist[x] > dis + w)
{
dist[x] = dis + w;
q.push({dist[x], x});
}
}
}
vector<int> index(n), dp(n + 1);
iota(index.begin(), index.end(), 1);
sort(index.begin(), index.end(), [&dist](auto a, auto b){
return dist[a] > dist[b];
});
dp[1] = 1;
for(auto & ind : index)
{
for(auto & [x, _]: g[ind])
{
if(dist[x] < dist[ind]) dp[x] = (dp[x] + dp[ind]) % mod;
}
}
return dp[n];
}
};
1723. 完成所有工作的最短时间 - 力扣（LeetCode）
class Solution {
public:
int ans = INT_MAX;
vector<int> jobs;
int energy(int k)
{
int n = jobs.size();
vector<int> s(k);
for(int i = 0; i < n; i ++ )//对于每项工作，找到一个最闲的工人分配
{
int kk = 0;
for(int j = 1; j < k; j ++ )
if(s[j] < s[kk]) kk = j;
s[kk] += jobs[i];
}
int res = 0;
for(auto &x : s)
res = max(x, res);//找到最大工作时间
ans = min(ans, res);
return res; //能量越小越好
}
void th(int k)
{
int n = jobs.size();
double T = 10000;//一个很高的温度
random_shuffle(jobs.begin(), jobs.end());//产生随机的工作分配顺序
while(T > 1e-4) //降温过程
{
T *= 0.92;
int a = rand() % n, b = rand() % n;
int ea = energy(k);
swap(jobs[a], jobs[b]);
int eb = energy(k);
int dt = eb - ea;
if(dt <= 0 || exp(-dt / T) > rand() / RAND_MAX) continue;//以一定概率接受
swap(jobs[a], jobs[b]);//不接受
}
}
int minimumTimeRequired(vector<int>& _jobs, int k) {
//每个工人至少分配一个工作
jobs = _jobs;
for(int i = 0; i < 7; i ++ )
th(k);
return ans;
}
};
状态压缩
class Solution {
public:
int minimumTimeRequired(vector<int>& jobs, int k) {
int n = jobs.size();
int m = (1 << n);
vector<int> all (m, 0);
for (int i = 1; i < m; ++i) {
all[i] = all[i & (i - 1)] + jobs[__builtin_ctz(i)];
}
// all[state] -> all time of state
vector<vector<int>> dp(k, vector<int>(m, INT_MAX));
for (int i = 0; i < m; ++i) {
dp[0][i] = all[i];
}
for (int i = 1; i < k; ++i) {
for (int j = 0; j < m; ++j) {
for (int x = j; x; x = (x - 1) & j) {
dp[i][j] = min(dp[i][j], max(dp[i - 1][j - x], all[x]));
}
}
}
return dp[k - 1][m - 1];
}
};
773. 滑动谜题 - 力扣（LeetCode）
#define x first
#define y second
class Solution {
public:
string end = "123450";
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
typedef pair<int, string> PIS;
int f(string s)
{
int res = 0;
for(int i = 0; i < s.size(); i ++ )
if(s[i] != '0')
{
int p = s[i] - '1';
res += abs(i / 3 - p / 3) + abs(i % 3 - p % 3);
}
return res;
}
int bfs(string state)
{
unordered_map <string, int> dist;
priority_queue <PIS, vector<PIS>, greater<PIS>> q;
q.push({f(state), state});//将初始状态入栈
dist[state] = 0;
while(q.size())
{
auto t = q.top();
q.pop();
string s = t.y;
if(s == end) break;
int x, y;
for(int i = 0; i < 6; i ++ )//找到0的位置
{
if(s[i] == '0')
{
x = i / 3;
y = i % 3;
break;
}
}
for(int i = 0; i < 4; i ++ )//和上下左右交换
{
int nx = x + dx[i], ny = y + dy[i];
if(nx < 0 || ny < 0 || nx > 1 || ny > 2) continue;//两行三列
string source = s;
swap(source[x * 3 + y], source[nx * 3 + ny]);
if(!dist.count(source) || dist[source] > dist[s] + 1)//dist是无穷大或者是比s + 1大
{
dist[source] = dist[s] + 1;
q.push({f(source) + dist[source], source});
}
}
}
return dist[end];
}
int slidingPuzzle(vector<vector<int>>& board) {
//A* 多次入栈，终点出栈只能确定终点的最短路径
//判断是否有解
string start;
for(auto &t : board)
for(auto &x : t)
start += x + '0';
int cnt = 0;
for(int i = 0; i < 6; i ++ )
for(int j = i + 1; j < 6; j ++ )
{
if(start[i] != '0' && start[j] != '0' && start[j] < start[i]) cnt ++;
}
if(cnt % 2) return -1;
else return bfs(start);
}
};
1239. 串联字符串的最大长度 - 力扣（LeetCode）
class Solution {
public:
vector<string> arr;
int n;
int ans = 0;
bool book[27];
int enengy()
{
int res = 0;
memset(book, 0, sizeof book);
for(int i = 0; i < n; i ++ )
{
int flag = true;
for(auto c: arr[i])
{
if(book[c - 'a'])
{
flag = false;
break;
};
book[c - 'a'] = true;
}
if(flag) res += arr[i].size();
}
return res;
}
void th()
{
srand(time(NULL));
random_shuffle(arr.begin(), arr.end());
for(int t = 1e6; t > 1e-6; t *= 0.97)
{
int a = rand() % n, b = rand() % n;
int ea = enengy();
swap(arr[a], arr[b]);
int eb = enengy();
ans = max({ans, ea, eb});
int dt = ea - eb;
if(dt < 0) continue;
if(exp(-1 * dt / t) >= rand() / RAND_MAX) continue;
swap(arr[a], arr[b]);
}
}
int maxLength(vector<string>& _arr) {
for(auto s: _arr)
{
memset(book, 0, sizeof book);
bool flag = true;
for(auto c: s)
{
if(book[c - 'a'])
{
flag = false;
break;
}
book[c - 'a'] = true;
}
if(flag) arr.push_back(s);
}
n = arr.size();
if(!n) return 0;
for(int i = 0; i < 2; i ++ )
th();
return ans;
}
};