LeetCode中的DFS

DFS

深度优先遍历算法，一般使用递归实现，注意递归结束条件

464. 我能赢吗

在 “100 game” 这个游戏中，两名玩家轮流选择从 1 到 10 的任意整数，累计整数和，先使得累计整数和达到 100 的玩家，即为胜者。

如果我们将游戏规则改为 “玩家不能重复使用整数” 呢？

例如，两个玩家可以轮流从公共整数池中抽取从 1 到 15 的整数（不放回），直到累计整数和 >= 100。

给定一个整数 maxChoosableInteger （整数池中可选择的最大数）和另一个整数 desiredTotal（累计和），判断先出手的玩家是否能稳赢（假设两位玩家游戏时都表现最佳）？

你可以假设 maxChoosableInteger 不会大于 20， desiredTotal 不会大于 300。

分析，1、用一个标准k的第i位来记录第i个数据是否被使用
2、用mem数组记忆，第i次谁会胜利，0为不知道 1为我方胜，-1为敌方胜利
3、用BFS来找到第i次将分胜负

递归结束条件：胜负已分时
1、当total<=0时，说明对方先达到目标了 说明输了
2、当mem[k]确定了输赢状态时
1）当我放抽取数字后，敌方抽取数字输了，则我方也赢了
反之，敌方赢了

class Solution {
public:
    int mem[1<<20]={};
    bool canIWin(int maxChoosableInteger, int desiredTotal) {
        if(desiredTotal<2)
            return true;
        else if((maxChoosableInteger*(maxChoosableInteger+1)/2)<desiredTotal)
            return false;
        else if(maxChoosableInteger==desiredTotal)
            return maxChoosableInteger%2;
        else return dfs(maxChoosableInteger,desiredTotal,0);
        
    }
    bool dfs(int M,int T,int k){
        if(mem[k]!=0) return mem[k]>0;
        if(T<=0) return false;

        for(int i=0;i<M;i++){
            if(!(k&(1<<i))&&!dfs(M,T-i-1,k|(1<<i))){
                mem[k]=1;
                return true;
            }

        }
        mem[k]=-1;
        return false;
    }
};

547. 朋友圈

班上有 N 名学生。其中有些人是朋友，有些则不是。他们的友谊具有是传递性。如果已知 A 是 B 的朋友，B 是 C 的朋友，那么我们可以认为 A 也是 C 的朋友。所谓的朋友圈，是指所有朋友的集合。

给定一个 N * N 的矩阵 M，表示班级中学生之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个学生互为朋友关系，否则为不知道。你必须输出所有学生中的已知的朋友圈总数。

解析：可以利用广度优先或者深度优先算法进行遍历，判断其的连接性，若能被遍历到则证明他们在一个朋友圈，遍历结束即可知朋友圈的数量，或者用并查集
1 用一个数组flag表示这n个人是否被查找过
2 当flag[i]==0则说明第i个人没被查找过，则开始dfs,dfs的次数即是朋友圈的数量
3 dfs的结束条件为当N个人都查找过，则结束，但是只有M[i][j]==1时才继续dfs遍历

class Solution {
public:
    int findCircleNum(vector<vector<int>>& M) {
        int n=M.size();
        vector<int> flag(n,0);
        int res=0;
        for(int i=0;i<n;i++){
            if(flag[i]==0){
                dfs(M,flag,i);
                res++;
            }
            
                
        }
        return res;
    }
    void dfs(vector<vector<int>>& M,vector<int>& flag,int i){
        for(int j=0;j<M.size();j++){
            if((M[i][j]==1)&&(flag[j]==0)){
                flag[j]=1;
                dfs(M,flag,j);
            }
                
        }
    }
};