DAG有向无环图 拓扑排序（207，208)
拓扑排序判断有无环。判断是否是有向无环图
方法1：DFS
思路：(自己多在演草纸上想想，把所有演草纸收集起来！）
题解：https://chenzhuo.blog.csdn.net/article/details/91127897
class Solution {
public:
bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
vector<int> flag(numCourses,0);
vector<vector<int>> tmp(numCourses);
if(prerequisites.empty()) return true;
for(int i=0;i<prerequisites.size();i++){
tmp[prerequisites[i][0]].push_back(prerequisites[i][1]);
}
bool ans=true;
for(int i=0;i<numCourses;i++){
ans = ans&&DFS(i,flag,tmp);
}
return ans;
}
bool DFS(int i,vector<int> &flag,vector<vector<int>> &tmp){//注意要加上"&"
if(flag[i]==-1){
return false;
}
if(flag[i]==1){
return true;
}
//第一次的入口：
flag[i]=-1;
for(int j=0;j<tmp[i].size();j++){
if(DFS(tmp[i][j],flag,tmp)){
continue;
}
return false;
}
flag[i]=1;
return true;
}
};
解法2：
方法二：根据入度判断
课程先后顺序可以理解为一个有向图，有解的条件是此图无环。因此我们可以依据其先后顺序构造有向图，并统计每门课程的入度（即其前一门课程的数量）。
然后将入度为0的所有课程压入栈中，然后将这些课程的下一门课程的入度减1，减完后入度为0则入栈。重复上述操作直到栈为空。 如果最后存在入度不为为0的节点就说明有环，无解。
《算法笔记》也有这个算法
class Solution {
public:
bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
vector<int> indegree(numCourses);
vector<vector<int>>Graph(numCourses);
queue<int> ZeroQ;
vector<int> ans,empty;//结果数组
int i,j,cnt=0;
int start,end;
//初始化邻接矩阵
for(i=0;i<prerequisites.size();i++){
start=prerequisites[i][0];
end=prerequisites[i][1];
Graph[end].push_back(start);
indegree[start]++;
}
//初始化队列
for(i=0;i<numCourses;i++){
if(indegree[i]==0){
ZeroQ.push(i);
}
}
while(!ZeroQ.empty()){
int v=ZeroQ.front();
ans.push_back(v);
ZeroQ.pop();
cnt++;
for(j=0;j<Graph[v].size();j++){
int u=Graph[v][j];
indegree[u]--;
if(indegree[u]==0){
ZeroQ.push(u);
}
}
}
if(cnt!=numCourses){
return false;
}
return true;
}
};
2019-09-28 09:44:28
简化到不能再简
class Solution {
public:
bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
vector<vector<int>> G(numCourses);
vector<int> degree(numCourses, 0), bfs;
for (auto& e : prerequisites)
G[e[1]].push_back(e[0]), degree[e[0]]++;
for (int i = 0; i < numCourses; ++i) if (!degree[i]) bfs.push_back(i);
for (int i = 0; i < bfs.size(); ++i)
for (int j: G[bfs[i]])
if (--degree[j] == 0) bfs.push_back(j);
return bfs.size() == numCourses;
}
};
第二天：
class Solution {
public:
bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
vector<vector<int>> graph(numCourses);
vector<int> inDegree(numCourses,0);
for(auto& edge : prerequisites){
graph[edge[1]].push_back(edge[0]);
++inDegree[edge[0]];
}
vector<int> result;
for(int i=0;i<numCourses;++i){
if(inDegree[i]==0) result.push_back(i);
}
for(int i=0;i<result.size();++i){
for(auto j : graph[result[i]]){
if(--inDegree[j]==0) result.push_back(j);
}
}
return result.size()==numCourses;
}
};
还是把自己想得太厉害了。然而自己并不能过目不忘。还是要多敲代码，多巩固，真的感觉到了如果能把自己做过的题保证大部分能做对，真的已经很厉害了。
这个题的代码和上个题完全一样。只是输出换了。
解法1：
队列
class Solution {
public:
vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
vector<int> indegree(numCourses);
vector<vector<int>>Graph(numCourses);
queue<int> ZeroQ;
vector<int> ans,empty;//结果数组
if(numCourses==1){
empty.push_back(0);
return empty;
}
int i,j,cnt=0;
int start,end;
//初始化邻接矩阵
for(i=0;i<prerequisites.size();i++){
start=prerequisites[i][0];
end=prerequisites[i][1];
Graph[end].push_back(start);
indegree[start]++;
}
//初始化队列
for(i=0;i<numCourses;i++){
if(indegree[i]==0){
ZeroQ.push(i);
}
}
while(!ZeroQ.empty()){
int v=ZeroQ.front();
ans.push_back(v);
ZeroQ.pop();
cnt++;
for(j=0;j<Graph[v].size();j++){
int u=Graph[v][j];
indegree[u]--;
if(indegree[u]==0){
ZeroQ.push(u);
}
}
}
if(cnt!=numCourses){
return empty;
}
return ans;
}
};
简化版：
2019-09-28
10:32:15
class Solution {
public:
vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
vector<int> result;//最优答案
vector<int> empty;//空数组
queue<int> temp;//存储入度为0的节点
if(numCourses==0){
empty.push_back(0);
return empty;
}
vector<vector<int>> graph(numCourses);
vector<int> inDegree(numCourses,0);
for(auto& edge : prerequisites){
graph[edge[1]].push_back(edge[0]);
inDegree[edge[0]]++;
}
for(int i=0;i<numCourses;++i){
if(!inDegree[i]){
temp.push(i);
}
}
int cnt=0;
while(!temp.empty()){
int pre = temp.front();result.push_back(pre);temp.pop();
++cnt;
for(auto i : graph[pre]){
if(--inDegree[i]==0) temp.push(i);
}
}
if(cnt!=numCourses) return empty;
return result;
}
};
2019-09-30
09:21:49
染色问题。
看的评论：采用了贪心算法。
class Solution {
public:
vector<int> gardenNoAdj(int N, vector<vector<int>>& paths) {
vector<vector<int>> result(N);
vector<int> color(N,1);
for(auto path : paths){
result[max(path[0],path[1])-1].push_back(min(path[0],path[1])-1);
}
for(int i=1;i<N;++i){
set<int> set_color{1,2,3,4};
for(int j=0;j<result[i].size();++j){
set_color.erase(color[result[i][j]]);
}
color[i] = *set_color.begin();
}
return color;
}
};
2019-10-04
11:40:54
解法1：Dijkstra算法
class Solution {
public:
int networkDelayTime(vector<vector<int>>& times, int N, int K) {
vector<vector<int>> v(N+1,vector<int>(N+1,-1));
for(int i=0;i<times.size();i++){
v[times[i][0]][times[i][1]]=times[i][2];
}
vector<int> S(N+1,-1),T(N+1,-1);
for(int i=1;i<N+1;i++)
T[i]=v[K][i];
T[K]=0;
int min_val=-1,min_idx=-1;
for(int c=0;c<N;c++){
//find min_val of T
min_val=-1;
for(int i=1;i<T.size();i++){
if(T[i]!=-1&&S[i]==-1){
if(min_val==-1||T[i]<min_val){
min_idx=i;
min_val=T[i];
}
}
}
S[min_idx]=min_val;
//update
for(int i=1;i<T.size();i++){
if(v[min_idx][i]!=-1&&(min_val+v[min_idx][i]<T[i]||T[i]==-1)){
T[i]=min_val+v[min_idx][i];
}
}
}
int res=-1;
for(int i=1;i<S.size();i++){
if(S[i]==-1)
return -1;
res=max(res,S[i]);
}
return res;
}
};
解法2：
2019-10-09（第二次）
Bellman-Ford算法
class Solution {
public:
int networkDelayTime(vector<vector<int>>& times, int N, int K) {
//Bellman-Ford算法
//存储图用邻接表,邻接矩阵需要遍历需要增加O(N)复杂度，将会升为O(N三次方)
vector<int> D(N+1,-1);
D[K] = 0;
for(int c=0;c<N-1;++c){ //只需要N-1 轮就可以，因为D[K] 为0，是已知的
for(int j=0;j<times.size();++j){
int src = times[j][0],des = times[j][1],d = times[j][2];
if(D[src]!=-1&&(D[src]+d<D[des]||D[des]==-1))
D[des]=D[src]+d;
}
}
int res = -1;
for(int i=1;i<D.size();i++){
if(D[i]==-1){
return -1;
}
else res = max(res,D[i]);
}
return res;
}
};
2019-10-05
09:40:27
解法3：
Bellman-Ford 算法的优化版——SPFA（Shorest path Faster Algorithm)算法
class Solution {
public:
int networkDelayTime(vector<vector<int>>& times, int N, int K) {
vector<vector<int>> v(N+1,vector<int>(N+1,-1));
for(int i=1;i<v.size();++i){
v[i][i]=0;
}
for(int i=0;i<times.size();++i){
v[times[i][0]][times[i][1]] = times[i][2];
}
vector<int> D(N+1,-1);
D[K] = 0;
queue<int> q;
q.push(K);
while(!q.empty()){
auto temp = q.front();
q.pop();
for(int i=1;i<v.size();++i){
if(v[temp][i]!=-1 &&(v[temp][i]+D[temp]<D[i]||D[i]==-1)){
D[i] = v[temp][i] + D[temp];
q.push(i);
}
}
}
int res = 0;
for(int i=1;i<N+1;++i){
if(D[i]==-1){
return -1;
}
res = max(D[i],res);
}
return res;
}
};
解法4：
Floyd 算法，可用来解决全源最短路问题
class Solution {
public:
int networkDelayTime(vector<vector<int>>& times, int N, int K) {
vector<vector<int>> v(N+1,vector<int>(N+1,-1));
for(int i=1;i<v.size();++i){
v[i][i]=0;
}
for(int i=0;i<times.size();++i){
v[times[i][0]][times[i][1]] = times[i][2];
}
for(int c=1;c<N+1;++c){
for(int i=1;i<N+1;++i){
for(int j=1;j<N+1;++j){
if(v[i][c]!=-1 && v[c][j]!=-1 &&(v[i][c]+v[c][j]<v[i][j]||v[i][j]==-1)){
v[i][j] = v[i][c]+v[c][j];
}
}
}
}
int res = 0;
for(int i=1;i<N+1;++i){
if(v[K][i]==-1){
return -1;
}
res = max(v[K][i],res);
}
return res;
}
};
解法1：
自己写的广搜判断是否是连通图
class Solution {
public:
bool canVisitAllRooms(vector<vector<int>>& rooms) {
vector<vector<int>> temp(rooms.size());
for(int i=0;i<rooms.size();++i){//初始化图
for(int j=0;j<rooms[i].size();++j){
temp[i].push_back(rooms[i][j]);
}
}
queue<int> q;
q.push(0);
vector<int> result(rooms.size(),0);
result[0] = 1;
while(!q.empty()){
int c = q.front();
q.pop();
for(auto cnt : temp[c]){
if(result[cnt]!=1){
result[cnt] = 1;
q.push(cnt);
}
}
}
for(int i=0;i<rooms.size();++i){
if(result[i]==0){
return false;
}
}
return true;
}
};
精简版代码：
class Solution {
public:
bool canVisitAllRooms(vector<vector<int>>& rooms) {
queue<int> q;
unordered_set<int> visited;
q.push(0);
visited.insert(0);
while(!q.empty()){
int t = q.front();q.pop();
visited.insert(t);
for(auto key : rooms[t]){
if(visited.count(key)) continue;
q.push(key);
}
}
return visited.size() == rooms.size();
}
};
解法2：DFS
劣质粗糙代码：
class Solution {
public:
int count = 0;
void dfs(int x,int N,vector<int> &visited,vector<vector<int>> rooms){
visited[x] = 1;
++count;
for(int i=0;i<rooms[x].size();++i){
if(!visited[rooms[x][i]]){
dfs(rooms[x][i],N,visited,rooms);
}
}
}
bool canVisitAllRooms(vector<vector<int>>& rooms) {
int N = rooms.size();
vector<int> visited(N,0);
dfs(0,N,visited,rooms);
return count == rooms.size();
}
};
解法1：
自己：
找到出度为0和入度为N-1的点，此点即为法官。
思路：构建一个出度数组和一个入度数组。
class Solution {
public:
int findJudge(int N, vector<vector<int>>& trust) {
vector<int> inDegree(N+1,0);
vector<int> outDegree(N+1,0);
for(auto edge : trust){
inDegree[edge[1]]++;
outDegree[edge[0]]++;
}
for(int i=1;i<N+1;++i){
if(outDegree[i]==0 && inDegree[i]==N-1){
return i;
}
}
return -1;
}
};
解法1：看的评论，自己没想到，自己对DFS的掌握还是不够
思路：DFS染色法，判断拓扑排序中是否有环，并找出不在环内的点（感觉和207，208题有些类似哦，都是判断拓扑排序中是否存在环）
DFS一直往前走，却走回了走过的结点不就是有环了嘛.
代码如下：
#define CIRCLE 1
#define TERMINAL 2
class Solution {
public:
vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
int n = graph.size();
vector<int> v(n);
vector<int> cnt;
for(int i=0;i<n;++i){
if(dfs(graph,v,i)==TERMINAL){
cnt.push_back(i);
}
}
return cnt;
}
int dfs(vector<vector<int>>& g,vector<int>& v,int i){
if(v[i]) return v[i];
v[i] = CIRCLE;
for(auto edge : g[i]){
if(dfs(g,v,edge)==CIRCLE){
return CIRCLE;
}
}
return v[i] = TERMINAL;
}
};
解法2：
BFS，和DFS的思路有很大不同。感觉两种方法的着手点是截然不同的。BFS是从入度，出度考虑的。
class Solution {
public:
vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
vector<int> res, outDegree(graph.size(),0);
vector<vector<int>> inDegree(graph.size());
for(int i=0;i<graph.size();++i){//初始化入队的vector<vector<int>>
for(int j : graph[i]){
inDegree[j].push_back(i);
outDegree[i]++;
}
}
for(int i=0;i<graph.size();++i){
if(outDegree[i]==0){
res.push_back(i);
}
}
int idx = 0;
while(idx < res.size()){
int i = res[idx];
++idx;
for(auto j : inDegree[i]){
outDegree[j]--;
if(outDegree[j]==0){
res.push_back(j);
}
}
}
sort(res.begin(),res.end());
return res;
}
};
简化版：
class Solution {
public:
vector<int> eventualSafeNodes(vector<vector<int>>& graph) {
vector<int> res, outDegree(graph.size(),0);
vector<vector<int>> inDegree(graph.size());
for(int i=0;i<graph.size();++i){//初始化入队的vector<vector<int>>
for(int j : graph[i]){
inDegree[j].push_back(i);
}
outDegree[i] = graph[i].size();
if(outDegree[i]==0){
res.push_back(i);
}
}
int idx = 0;
while(idx < res.size()){
int i = res[idx];
++idx;
for(auto j : inDegree[i]){
outDegree[j]--;
if(outDegree[j]==0){
res.push_back(j);
}
}
}
sort(res.begin(),res.end());
return res;
}
};
为下面代码做铺垫的新知识：
https://www.cnblogs.com/hustfeiji/articles/5174983.html
这就是说multiset内部是自动排好序的。
解法1：
思路：DFS
class Solution {
public:
map<string, multiset<string>> targets;
vector<string> route;
vector<string> findItinerary(vector<vector<string>>& tickets) {
for (auto ticket : tickets)
targets[ticket[0]].insert(ticket[1]);
visit("JFK");
return vector<string>(route.rbegin(), route.rend());
}
void visit(string airport) {
while (targets[airport].size()) {
string next = *targets[airport].begin();
targets[airport].erase(targets[airport].begin());
visit(next);
}
route.push_back(airport);
}
};
本题是一道树的题目。
就是返回每层各个元素相加和的最大的那个层
法1：
BFS
class Solution {
public:
int maxLevelSum(TreeNode* root) {
queue<TreeNode*> q;
q.push(root);
int maxv=root->val,res=1,layer=0;
while(!q.empty()){
layer++;
int n=q.size(),sum=0;
for(int i=0;i<n;i++){
TreeNode* tmp=q.front();q.pop();
sum+=tmp->val;
if(tmp->left) q.push(tmp->left);
if(tmp->right) q.push(tmp->right);
}
if(sum>maxv){
maxv=sum;
res=layer;
}
}
return res;
}
};
法2:
DFS：
借助map结构，遍历到各个层时，map[n] 就加上那个属于本层的节点的元素值。
class Solution {
public:
map<int,int> mp;
void dfs(TreeNode* root, int d){
if(!root){
return;
}
mp[d] += root->val;
dfs(root->left,d+1);
dfs(root->right,d+1);
}
int maxLevelSum(TreeNode* root) {
int res = 0, max_sum = INT_MIN;
dfs(root,1);
auto iter = mp.begin();
while(iter != mp.end()){
if(iter->second > max_sum){
max_sum = iter->second;
res = iter->first;
}
iter++;
}
return res;
}
};
解法1：
并查集
题目很拗口。。。但本质就是计算一个图的连通分量的个数，总石头数减去连通分量个数就是结果。
每次move移除掉一个共享同一行或列的（两个或多个石头）中的一个 如果把每个石头当一个点，如果两个石头间有共同x或y坐标，就给这两个点画一条线（边）。那么对应move操作就是把其中一条边的一个点删除，直到不能删为止，也就是说图里面的连通分量的点是要删去的，一直删到连通分量里面没有边（即只剩下一个点）
class Solution {
public:
vector<int> vec;
int removeStones(vector<vector<int>>& stones) {
int n = stones.size();
vec = vector<int>(n);
for(int i=0;i<n;++i){
vec[i] = i;
}
for(int i=0;i<n;++i){
for(int j=0;j<n;++j){
if(stones[i][0] == stones[j][0] || stones[i][1] == stones[j][1]){
Union(i,j);
}
}
}
int cnt=0;
for(int i=0;i<n;++i){
if(vec[i]==i){
cnt++;
}
}
return n - cnt;
}
int find(int i){
if(vec[i]!=i){
vec[i] = find(vec[i]);
}
return vec[i];
}
void Union(int x,int y){
int faA = find(x);
int faB = find(y);
vec[faA] = faB;
}
};
解法2：
DFS
DFS方法的解题思路： 用dfs求连通分量的个数 最后结果 = stones.size() - 连通分量的个数
class Solution {
public:
int removeStones(vector<vector<int>>& stones) {
vector<bool> vis(stones.size(),false);
int res = 0;
for(int i=0;i<stones.size();++i){
if(vis[i]==true){
continue;
}
dfs(stones,vis,i);
res++;
}
return stones.size()-res;
}
void dfs(vector<vector<int>>& stones,vector<bool>& vis,int k){
vis[k] = true;
int x = stones[k][0], y = stones[k][1];
for(int i=0;i<stones.size();++i){
if(vis[i]==true)
continue;
if(stones[i][0] == x || stones[i][1]==y){
dfs(stones,vis,i);
}
}
}
};
解法1：
并查集
class Solution {
public:
int find(vector<int>& union_find, int idx){
if(union_find[idx] == -1) return idx;
return find(union_find,union_find[idx]);
}
void Union(vector<int>&union_find, int idx1, int idx2){
int parent1 = find(union_find,idx1);
int parent2 = find(union_find,idx2);
//Always keep the same rule, merge parent1 to parent2;
if(parent1 != parent2) union_find[parent1] = parent2;
}
vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
vector<vector<string>> res;
int n = accounts.size();
vector<int> union_find(n,-1);
map<string,int> mailUser;
map<int,vector<string>> mails;
for(int i=0; i<accounts.size(); i++){
for(int j=1; j<accounts[i].size(); j++){
if(mailUser.count(accounts[i][j])){
// if the same email has been stored before, find its user and unite them
int idx1 = find(union_find,i);
int idx2 = find(union_find,mailUser[accounts[i][j]]);
Union(union_find,idx1,idx2);
}
//**IMPORTANT**
//We can still assign this mail to the "current" user, because we have already performed union
mailUser[accounts[i][j]] = i;
}
}
for(auto pair:mailUser){
//Find its real user
int user = find(union_find,pair.second);
mails[user].push_back(pair.first);
}
for(auto pair:mails){
vector<string> temp = pair.second;
sort(temp.begin(),temp.end());
temp.insert(temp.begin(),accounts[pair.first][0]);
res.push_back(temp);
}
return res;
}
};
解法1：
DFS C++
class Solution {
private:
unordered_map<string,vector<pair<string,double>>> children;
pair<bool,double> search(string& a,string& b,unordered_set<string>& visited,double val){
if(visited.count(a) == 0){
visited.insert(a);
for(auto p : children[a]){
double temp = val * p.second;
if(p.first == b) return make_pair(true,temp);
auto result = search(p.first,b,visited,temp);
if(result.first){
return result;
}
}
}
return make_pair(false,-1.0);
}
public:
vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries) {
vector<double> ans;
for(int i = 0;i<equations.size();++i){
children[equations[i][0]].push_back(make_pair(equations[i][1],values[i]));
children[equations[i][1]].push_back(make_pair(equations[i][0],
1.0 / values[i]));
}
for(auto p : queries){
unordered_set<string> visited;
// p .first == p.second is special case
ans.push_back(p[0] == p[1] && children.count(p[0]) ?
1.0 : search(p[0],p[1],visited,1.0).second);
}
return ans;
}
};
class Solution {
public:
int maxPoints(vector<vector<int>>& points) {
//两点确定一条直线
if(points.size()<3)return points.size();
int Max=0;
for(int i=0;i<points.size();++i)//i表示数组中的第i+1个点
{
//same用来表示和i一样的点
int same=1;
for(int j=i+1;j<points.size();++j)//j表示数组中的第j+1个点
{
int count=0;
// i、j在数组中是重复点，计数
if(points[i][0]==points[j][0]&&points[i][1]==points[j][1])same++;
else{//i和j不是重复点，则计算和直线ij在一条直线上的点
count++;
long long xDiff = (long long)(points[i][0] - points[j][0]);//Δx1
long long yDiff = (long long)(points[i][1] - points[j][1]);//Δy1
for (int k = j + 1; k < points.size(); k ++)//Δy1/Δx1=Δy2/Δx2 => Δx1*Δy2=Δy1*Δx2，计算和直线ji在一条直线上的点
if (xDiff * (points[i][1] - points[k][1]) == yDiff * (points[i][0] - points[k][0]))
count++;
}
Max=max(Max,same+count);
}
if(Max>points.size()/2)return Max;//若某次最大个数超过所有点的一半，则不可能存在其他直线通过更多的点
}
return Max;
}
};