Leetcode_入门_图
二分图
如果可以用两种颜色对图中的节点进行着色，并且保证相邻的节点颜色不同，那么这个图就是二分图。
1、判断二分图（785、Medium）
1）题目要求
给定一个无向图graph，当这个图为二分图时返回true。
如果我们能将一个图的节点集合分割成两个独立的子集A和B，并使图中的每一条边的两个节点一个来自A集合，一个来自B集合，我们就将这个图称为二分图。
graph将会以邻接表方式给出，graph[i]表示图中与节点i相连的所有节点。每个节点都是一个在0到graph.length-1之间的整数。这图中没有自环和平行边： graph[i] 中不存在i，并且graph[i]中没有重复的值。
示例 1:
输入: [[1,3], [0,2], [1,3], [0,2]]
输出: true
解释:
无向图如下:
0----1
| |
| |
3----2
我们可以将节点分成两组: {0, 2} 和 {1, 3}。
示例 2:
输入: [[1,2,3], [0,2], [0,1,3], [0,2]]
输出: false
解释:
无向图如下:
0----1
| \ |
| \ |
3----2
我们不能将节点分割成两个独立的子集。
注意:
graph 的长度范围为 [1, 100]。
graph[i] 中的元素的范围为 [0, graph.length - 1]。
graph[i] 不会包含 i 或者有重复的值。
图是无向的: 如果j 在 graph[i]里边, 那么 i 也会在 graph[j]里边。
2）我的解法
class Solution {
Set<Integer> l1=new HashSet<>();
Set<Integer> l2=new HashSet<>();
public boolean dfs(int num,int[][] graph,int tag){
if(tag==1){
if(l1.contains(num))return true;
if(l2.contains(num))return false;
l1.add(num);
for(int i=0;i<graph[num].length;i++){
if(!dfs(graph[num][i],graph,2))return false;
}
return true;
}
else {
if(l2.contains(num))return true;
if(l1.contains(num))return false;
l2.add(num);
for(int i=0;i<graph[num].length;i++){
if(!dfs(graph[num][i],graph,1))return false;
}
return true;
}
}
public boolean isBipartite(int[][] graph) {
for(int i=0;i<graph.length;i++){
if(!l1.contains(i)&&!l2.contains(i)){
if(!dfs(i,graph,1))return false;
}
}
return true;
}
}
3）其他解法
1、广度优先
class Solution {
public boolean isBipartite(int[][] graph) {
// 定义 visited 数组，初始值为 0 表示未被访问，赋值为 1 或者 -1 表示两种不同的颜色。
int[] visited = new int[graph.length];
Queue<Integer> queue = new LinkedList<>();
// 因为图中可能含有多个连通域，所以我们需要判断是否存在顶点未被访问，若存在则从它开始再进行一轮 bfs 染色。
for (int i = 0; i < graph.length; i++) {
if (visited[i] != 0) {
continue;
}
// 每出队一个顶点，将其所有邻接点染成相反的颜色并入队。
queue.offer(i);
visited[i] = 1;
while (!queue.isEmpty()) {
int v = queue.poll();
for (int w: graph[v]) {
// 如果当前顶点的某个邻接点已经被染过色了，且颜色和当前顶点相同，说明此无向图无法被正确染色，返回 false。
if (visited[w] == visited[v]) {
return false;
}
if (visited[w] == 0) {
visited[w] = -visited[v];
queue.offer(w);
}
}
}
}
return true;
}
}
2、深度优先
class Solution {
public boolean isBipartite(int[][] graph) {
// 定义 visited 数组，初始值为 0 表示未被访问，赋值为 1 或者 -1 表示两种不同的颜色。
int[] visited = new int[graph.length];
// 因为图中可能含有多个连通域，所以我们需要判断是否存在顶点未被访问，若存在则从它开始再进行一轮 dfs 染色。
for (int i = 0; i < graph.length; i++) {
if (visited[i] == 0 && !dfs(graph, i, 1, visited)) {
return false;
}
}
return true;
}
private boolean dfs(int[][] graph, int v, int color, int[] visited) {
// 如果要对某顶点染色时，发现它已经被染色了，则判断它的颜色是否与本次要染的颜色相同，如果矛盾，说明此无向图无法被正确染色，返回 false。
if (visited[v] != 0) {
return visited[v] == color;
}
// 对当前顶点进行染色，并将当前顶点的所有邻接点染成相反的颜色。
visited[v] = color;
for (int w: graph[v]) {
if (!dfs(graph, w, -color, visited)) {
return false;
}
}
return true;
}
}
3、并查集
class Solution {
public boolean isBipartite(int[][] graph) {
// 初始化并查集
UnionFind uf = new UnionFind(graph.length);
// 遍历每个顶点，将当前顶点的所有邻接点进行合并
for (int i = 0; i < graph.length; i++) {
int[] adjs = graph[i];
for (int w: adjs) {
// 若某个邻接点与当前顶点已经在一个集合中了，说明不是二分图，返回 false。
if (uf.isConnected(i, w)) {
return false;
}
uf.union(adjs[0], w);
}
}
return true;
}
}
// 并查集
class UnionFind {
int[] roots;
public UnionFind(int n) {
roots = new int[n];
for (int i = 0; i < n; i++) {
roots[i] = i;
}
}
public int find(int i) {
if (roots[i] == i) {
return i;
}
return roots[i] = find(roots[i]);
}
// 判断 p 和 q 是否在同一个集合中
public boolean isConnected(int p, int q) {
return find(q) == find(p);
}
// 合并 p 和 q 到一个集合中
public void union(int p, int q) {
roots[find(p)] = find(q);
}
}
作者：sweetiee
链接： link
来源：力扣（LeetCode）
4）自己的优化代码
class Solution {
int[] visited;
public boolean dfs(int num,int[][] graph,int color){
if(visited[num]!=0)return visited[num]==color;
visited[num]=color;
for(int i=0;i<graph[num].length;i++){
if(!dfs(graph[num][i],graph,-color))return false;
}
return true;
}
public boolean isBipartite(int[][] graph) {
visited=new int[graph.length];
for(int i=0;i<graph.length;i++){
if(visited[i]==0){
if(!dfs(i,graph,1))return false;
}
}
return true;
}
}
5）学到的东西
用1代表一组，-1代表二组，0代表未访问
不但可以少用点空间，还可以避免分类讨论，省去hashset进行散列的时间，减少代码
拓扑排序
常用于在具有先序关系的任务规划中。
1、课程表（207、Medium）
1）题目要求
你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-1 。
在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1]
给定课程总量以及它们的先决条件，请你判断是否可能完成所有课程的学习？
示例 1:
输入: 2, [[1,0]]
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。
示例 2:
输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。
提示：
输入的先决条件是由 边缘列表 表示的图形，而不是 邻接矩阵 。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
1 <= numCourses <= 10^5
2）我的解法
class Solution {
Map<Integer,ArrayList<Integer>> map=new HashMap<>();
ArrayList<Integer> temp=null;
int[] Out;//出度
int[] In;//入度
public void tuopu(int cur){
if(!map.containsKey(cur))return;
temp=map.get(cur);
map.remove(cur);
for(Integer i:temp){
In[i]--;
if(In[i]>0)continue;
tuopu(i);
}
}
public boolean canFinish(int numCourses, int[][] prerequisites) {
Out=new int[numCourses];
In=new int[numCourses];
if(prerequisites.length==0)return true;
for(int i=0;i<prerequisites.length;i++){
if(!map.containsKey(prerequisites[i][0])){
ArrayList<Integer> list=new ArrayList<>();
list.add(prerequisites[i][1]);
map.put(prerequisites[i][0],list);
}else{
temp=map.get(prerequisites[i][0]);
temp.add(prerequisites[i][1]);
}
Out[prerequisites[i][0]]++;
In[prerequisites[i][1]]++;
}
//依次减去入度为0的结点，最后结点数不为0即有环
for(int i=0;i<prerequisites.length;i++){
if(In[prerequisites[i][0]]>0)continue;
tuopu(prerequisites[i][0]);
}
return (map.size()==0);
}
}
3）其他解法
看到一个运气算法，笑死我了
class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
return new Random().nextBoolean();
}
}
作者：cao-yao-cao-yao-cao
链接：link
来源：力扣（LeetCode）
当然了，以上只是娱乐，下面的是认真的
1、广度优先
class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
int[] indegrees = new int[numCourses];
List<List<Integer>> adjacency = new ArrayList<>();
Queue<Integer> queue = new LinkedList<>();
for(int i = 0; i < numCourses; i++)
adjacency.add(new ArrayList<>());
// Get the indegree and adjacency of every course.
for(int[] cp : prerequisites) {
indegrees[cp[0]]++;
adjacency.get(cp[1]).add(cp[0]);
}
// Get all the courses with the indegree of 0.
for(int i = 0; i < numCourses; i++)
if(indegrees[i] == 0) queue.add(i);
// BFS TopSort.
while(!queue.isEmpty()) {
int pre = queue.poll();
numCourses--;
for(int cur : adjacency.get(pre))
if(--indegrees[cur] == 0) queue.add(cur);
}
return numCourses == 0;
}
}
作者：jyd
链接：link
来源：力扣（LeetCode）
2、深度优先（回溯）
class Solution {
public boolean canFinish(int numCourses, int[][] prerequisites) {
List<List<Integer>> adjacency = new ArrayList<>();
for(int i = 0; i < numCourses; i++)
adjacency.add(new ArrayList<>());
int[] flags = new int[numCourses];
for(int[] cp : prerequisites)
adjacency.get(cp[1]).add(cp[0]);
for(int i = 0; i < numCourses; i++)
if(!dfs(adjacency, flags, i)) return false;
return true;
}
private boolean dfs(List<List<Integer>> adjacency, int[] flags, int i) {
if(flags[i] == 1) return false;
if(flags[i] == -1) return true;
flags[i] = 1;
for(Integer j : adjacency.get(i))
if(!dfs(adjacency, flags, j)) return false;
flags[i] = -1;
return true;
}
}
作者：jyd
链接：link
来源：力扣（LeetCode）
4）自己的优化代码
class Solution {
List<List<Integer>> al;
List<Integer> temp=null;
int[] In;//入度
int Num;
public void tuopu(int cur){
if(al.get(cur)==null)return;//已经被删去的结点存的即为Null，充当备忘录使用
Num--;
if(al.get(cur).size()==0){al.set(cur,null);return;}
temp=al.get(cur);
al.set(cur,null);
for(Integer i:temp){
In[i]--;
if(In[i]>0)continue;
tuopu(i);
}
}
public boolean canFinish(int numCourses, int[][] prerequisites) {
In=new int[numCourses];
al=new ArrayList<List<Integer>>(numCourses);
Num=numCourses;
for(int i=0;i<numCourses;i++)al.add(new ArrayList<Integer>());//所有结点存个空数组
for(int i=0;i<prerequisites.length;i++){
al.get(prerequisites[i][0]).add(prerequisites[i][1]);
In[prerequisites[i][1]]++;
}
//依次删去入度为0的结点，最后结点数不为0即有环
for(int i=0;i<numCourses;i++){
if(In[i]>0)continue;
tuopu(i);
}
return Num==0;
}
}
5）学到的东西
拓扑排序：依次删去入度为0的结点，最后结点数不为0就代表有环
涉及到频繁增加删除时，尽量别用hashmap，因为在数据量较大时它的put和remove操作比较繁琐
已经被访问（即已经被删除）的结点应该记录一下（备忘录）
2、课程表 II（210、Medium）
1）题目要求
现在你总共有 n 门课需要选，记为 0 到 n-1。
在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。
可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。
示例 1:
输入: 2, [[1,0]]
输出: [0,1]
解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
示例 2:
输入: 4, [[1,0],[2,0],[3,1],[3,2]]
输出: [0,1,2,3] or [0,2,1,3]
解释: 总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。
说明:
输入的先决条件是由边缘列表表示的图形，而不是邻接矩阵。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
提示:
这个问题相当于查找一个循环是否存在于有向图中。如果存在循环，则不存在拓扑排序，因此不可能选取所有课程进行学习。
通过 DFS 进行拓扑排序 - 一个关于Coursera的精彩视频教程（21分钟），介绍拓扑排序的基本概念。
拓扑排序也可以通过 BFS 完成。
2）我的解法
bfs+拓扑
class Solution {
public int[] findOrder(int numCourses, int[][] prerequisites) {
List<List<Integer>> biao=new ArrayList<>();//图
int[] In=new int[numCourses];//入度
int[] result=new int[numCourses];
Queue<Integer> q=new LinkedList<Integer>();
for(int i=0;i<numCourses;i++)biao.add(new ArrayList<Integer>());
for(int i=0;i<prerequisites.length;i++){
biao.get(prerequisites[i][1]).add(prerequisites[i][0]);
In[prerequisites[i][0]]++;
}
for(int i=0;i<numCourses;i++){
if(In[i]==0)q.add(i);
}
int cur=0,index=0;
int Num=numCourses;
while(!q.isEmpty()){
cur=q.poll();
result[index++]=cur;
Num--;
for(Integer i:biao.get(cur)){
In[i]--;
if(In[i]>0)continue;
q.add(i);
}
}
if(Num>0)return new int[0];
return result;
}
}
3）其他解法
1、
class Solution {
public int[] findOrder(int numCourses, int[][] prerequisites) {
if (numCourses <= 0) {
return new int[0];
}
HashSet<Integer>[] adj = new HashSet[numCourses];
for (int i = 0; i < numCourses; i++) {
adj[i] = new HashSet<>();
}
// [1,0] 0 -> 1
int[] inDegree = new int[numCourses];
for (int[] p : prerequisites) {
adj[p[1]].add(p[0]);
inDegree[p[0]]++;
}
Queue<Integer> queue = new LinkedList<>();
for (int i = 0; i < numCourses; i++) {
if (inDegree[i] == 0) {
queue.offer(i);
}
}
int[] res = new int[numCourses];
// 当前结果集列表里的元素个数，正好可以作为下标
int count = 0;
while (!queue.isEmpty()) {
// 当前入度为 0 的结点
Integer head = queue.poll();
res[count] = head;
count++;
Set<Integer> successors = adj[head];
for (Integer nextCourse : successors) {
inDegree[nextCourse]--;
// 马上检测该结点的入度是否为 0，如果为 0，马上加入队列
if (inDegree[nextCourse] == 0) {
queue.offer(nextCourse);
}
}
}
// 如果结果集中的数量不等于结点的数量，就不能完成课程任务，这一点是拓扑排序的结论
if (count == numCourses) {
return res;
}
return new int[0];
}
}
2、
import java.util.HashSet;
import java.util.Stack;
/**
* @author liwei
* @date 18/6/24 下午4:10
*/
public class Solution3 {
/**
* @param numCourses
* @param prerequisites
* @return
*/
public int[] findOrder(int numCourses, int[][] prerequisites) {
if (numCourses <= 0) {
// 连课程数目都没有，就根本没有办法完成练习了，根据题意应该返回空数组
return new int[0];
}
int plen = prerequisites.length;
if (plen == 0) {
// 没有有向边，则表示不存在课程依赖，任务一定可以完成
int[] ret = new int[numCourses];
for (int i = 0; i < numCourses; i++) {
ret[i] = i;
}
return ret;
}
int[] marked = new int[numCourses];
// 初始化有向图 begin
HashSet<Integer>[] graph = new HashSet[numCourses];
for (int i = 0; i < numCourses; i++) {
graph[i] = new HashSet<>();
}
// 初始化有向图 end
// 有向图的 key 是前驱结点，value 是后继结点的集合
for (int[] p : prerequisites) {
graph[p[1]].add(p[0]);
}
// 使用 Stack 或者 List 记录递归的顺序，这里使用 Stack
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < numCourses; i++) {
if (dfs(i, graph, marked, stack)) {
// 注意方法的语义，如果图中存在环，表示课程任务不能完成，应该返回空数组
return new int[0];
}
}
// 在遍历的过程中，一直 dfs 都没有遇到已经重复访问的结点，就表示有向图中没有环
// 所有课程任务可以完成，应该返回 true
// 下面这个断言一定成立，这是拓扑排序告诉我们的结论
assert stack.size() == numCourses;
int[] ret = new int[numCourses];
// 想想要怎么得到结论，我们的 dfs 是一致将后继结点进行 dfs 的
// 所以压在栈底的元素，一定是那个没有后继课程的结点
// 那个没有前驱的课程，一定在栈顶，所以课程学习的顺序就应该是从栈顶到栈底
// 依次出栈就好了
for (int i = 0; i < numCourses; i++) {
ret[i] = stack.pop();
}
return ret;
}
/**
* 注意这个 dfs 方法的语义
*
* @param i 当前访问的课程结点
* @param graph
* @param marked 如果 == 1 表示正在访问中，如果 == 2 表示已经访问完了
* @return true 表示图中存在环，false 表示访问过了，不用再访问了
*/
private boolean dfs(int i,
HashSet<Integer>[] graph,
int[] marked,
Stack<Integer> stack) {
// 如果访问过了，就不用再访问了
if (marked[i] == 1) {
// 从正在访问中，到正在访问中，表示遇到了环
return true;
}
if (marked[i] == 2) {
// 表示在访问的过程中没有遇到环，这个节点访问过了
return false;
}
// 走到这里，是因为初始化呢，此时 marked[i] == 0
// 表示正在访问中
marked[i] = 1;
// 后继结点的集合
HashSet<Integer> successorNodes = graph[i];
for (Integer successor : successorNodes) {
if (dfs(successor, graph, marked, stack)) {
// 层层递归返回 true ，表示图中存在环
return true;
}
}
// i 的所有后继结点都访问完了，都没有存在环，则这个结点就可以被标记为已经访问结束
// 状态设置为 2
marked[i] = 2;
stack.add(i);
// false 表示图中不存在环
return false;
}
}
作者：liweiwei1419
链接：link
来源：力扣（LeetCode）
4）自己的优化代码
class Solution {
public int[] findOrder(int numCourses, int[][] prerequisites) {
List<List<Integer>> biao=new ArrayList<>();//图
int[] In=new int[numCourses];//入度
int[] result=new int[numCourses];
Queue<Integer> q=new LinkedList<Integer>();
for(int i=0;i<numCourses;i++)biao.add(new ArrayList<Integer>());
for(int i=0;i<prerequisites.length;i++){
biao.get(prerequisites[i][1]).add(prerequisites[i][0]);
In[prerequisites[i][0]]++;
}
for(int i=0;i<numCourses;i++){
if(In[i]==0)q.offer(i);
}
int cur=0,index=0;
int Num=numCourses;
while(!q.isEmpty()){
cur=q.poll();
result[index++]=cur;
Num--;
for(Integer i:biao.get(cur)){
In[i]--;
if(In[i]>0)continue;
q.offer(i);
}
}
if(Num>0)return new int[0];//有环
return result;
}
}
5）学到的东西
Queue: offer,poll,isEmpty
ArrayList< Integer>[] list=new ArrayList[5];
HashSet< Integer>[] adj = new HashSet[numCourses];
这种数组后面不要加尖括号，否则报错
并查集
并查集可以动态地连通两个点，并且可以非常快速地判断两个点是否连通。
1、冗余连接（684、Medium）
1）题目要求
在本问题中, 树指的是一个连通且无环的无向图。
输入一个图，该图由一个有着N个节点 (节点值不重复1, 2, …, N) 的树及一条附加的边构成。附加的边的两个顶点包含在1到N中间，这条附加的边不属于树中已存在的边。
结果图是一个以边组成的二维数组。每一个边的元素是一对[u, v] ，满足 u < v，表示连接顶点u 和v的无向图的边。
返回一条可以删去的边，使得结果图是一个有着N个节点的树。如果有多个答案，则返回二维数组中最后出现的边。答案边 [u, v] 应满足相同的格式 u < v。
示例 1：
输入: [[1,2], [1,3], [2,3]]
输出: [2,3]
解释: 给定的无向图为:
1
/
2 - 3
示例 2：
输入: [[1,2], [2,3], [3,4], [1,4], [1,5]]
输出: [1,4]
解释: 给定的无向图为:
5 - 1 - 2
| |
4 - 3
注意:
输入的二维数组大小在 3 到 1000。
二维数组中的整数在1到N之间，其中N是输入数组的大小。
更新(2017-09-26):
我们已经重新检查了问题描述及测试用例，明确图是无向 图。对于有向图详见冗余连接II。对于造成任何不便，我们深感歉意。
2）我的解法
class Solution {
public int[] findRedundantConnection(int[][] edges) {
UFSet u=new UFSet(edges.length);
for(int i=0;i<edges.length;i++){
if(u.isConnected(edges[i][0]-1,edges[i][1]-1))return edges[i];
u.union(edges[i][0]-1,edges[i][1]-1);
}
return new int[0];
}
}
class UFSet{
private int[] data;
public UFSet(int size){
data=new int[size];
for(int i=0;i<size;i++)data[i]=i;
}
public int findRoot(int i){//返回结点i所处树的根结点
if(data[i]==i)return i;
data[i]=findRoot(data[i]);//路径压缩
return data[i];
}
public boolean isConnected(int i,int j){//判断两个结点是否处于同一颗树下
return findRoot(i)==findRoot(j);
}
public void union(int i,int j){//合并
data[findRoot(i)]=findRoot(j);
}
}
3）其他解法
class Solution {
//缓存结果集
int[] result = new int[2];
public int[] findRedundantConnection(int[][] edges) {
int[] father = new int[edges.length + 1];
for (int i = 0; i < father.length; i++) {
father[i] = i;
}
for (int[] edge : edges) {
union(father, edge[0], edge[1]);
}
return result;
}
//路径压缩
public int findXFather(int[] father, int x) {
while (father[x]!=x){
father[x] = father[father[x]];
x = father[x];
}
return x;
}
//合并两个能连接上的点，father合为最后确定的father
public void union(int[] father, int x, int y) {
int xFather = findXFather(father, x);
int yFather = findXFather(father, y);
if (xFather != yFather) {
father[xFather]=yFather;
} else {
//在发现两个点的连接已经存在时，就更新缓存，题目要最后一个，遍历到最后一个就是结果
result[0] = x;
result[1] = y;
}
}
}
作者：luma730
链接：link
来源：力扣（LeetCode）
4）自己的优化代码
class Solution {
public int[] findRedundantConnection(int[][] edges) {
UFSet u=new UFSet(edges.length);
for(int i=0;i<edges.length;i++){
if(u.isConnected(edges[i][0]-1,edges[i][1]-1))return edges[i];
u.union(edges[i][0]-1,edges[i][1]-1);
}
return new int[0];
}
}
class UFSet{
private int[] data;
public UFSet(int size){
data=new int[size];
for(int i=0;i<size;i++)data[i]=i;
}
public int findRoot(int i){//返回结点i所处树的根结点
if(data[i]==i)return i;
data[i]=findRoot(data[i]);//路径压缩
return data[i];
}
public boolean isConnected(int i,int j){//判断两个结点是否处于同一颗树下
return findRoot(i)==findRoot(j);
}
public void union(int i,int j){//合并
data[findRoot(i)]=findRoot(j);
}
}
5）学到的东西
并查集的定义、实现、用法
645
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
