LeetCode 171周赛题解

1317. 将整数转换为两个无零整数的和

class Solution {
public:
    bool check(int n){
        while(n){
            if(n%10==0){
                return false;
            }
            n=n/10;
        }
        return true;
    }
    vector<int> getNoZeroIntegers(int n) {
        for(int i=1;i<=n;i++){
            if(check(i)&&check(n-i))return {i,n-i};
        }
        return {};
    }
};

1318. 或运算的最小翻转次数

class Solution {
public:
    int minFlips(int a, int b, int c) {
        int cnt=0;
        while(a>0||b>0||c>0){
            int m=a&1,n=b&1,k=c&1;
            if((m|n)!=k){
                if(k==1){
                    cnt++;
                    //cout<<cnt<<endl;
                }else{
                    if(m==1&&n==1)cnt+=2;
                    else cnt++;
                    //cout<<cnt;
                }
            }
            a=a>>1;
            b=b>>1;
            c=c>>1;
        }
        return cnt;
    }
};

1319. 连通网络的操作次数

解法一：并查集：

const int maxn=1e5+10;
int father[maxn];
class Solution {
public:
    //是一个图论的问题。。。
    //首先计算一下连通图的数量，一个连通图的最小边就是机子个数减一，剩下的线如果等于连通图数减一，那么就是符合条件的。。。
    //如何计算连通图的数量？？？
    int find(int x){
        while(father[x]!=x){
            x=father[x];
        }
        return x;
    }
    void Uni(int a,int b){
        int f1=find(a);
        int f2=find(b);
        if(f1>f2)swap(f1,f2);
        father[f2]=f1;
    }
    int makeConnected(int n, vector<vector<int>>& connections) {
        int m=connections.size();//表示的是总共有多少条边；
        //使用并查集求解连通图的数量.
        if(m<n-1)return -1;
        for(int i=0;i<n;i++){
            father[i]=i;//初始化
        }
        //set<int>cl;
        for(int i=0;i<m;i++){
            int k=connections[i][0],p=connections[i][1];
            // cl.insert(k);
            // cl.insert(p);
            Uni(k,p);
        }
        //int num=cl.size()-1;//表示的是结点数量减一，即所需要的最少边的数量。
        int cnt=0;
        for(int i=0;i<n;i++){
            if(father[i]==i)cnt++;
        }
        return cnt-1;//最小的需要线路是连通图数减一，不需要使用set
        
    }
};

解法二：DFS

const int maxn=1e5+10;
vector<int>E[maxn];
class Solution {
public:
    //DFS解法,DFS需要注意的是，这个connections图是单向的图，但是DFS需要的是双向的图。。。
    void dfs(int x,vector<int>&vis){
        vis[x]=1;
        for(int i=0;i<E[x].size();i++){
            int v=E[x][i];
            if(vis[v]==0){
                dfs(v,vis);
            }
        }
    }
    int makeConnected(int n, vector<vector<int>>& connections) {
        int m=connections.size();
        vector<int>vis(n+1,0);//表示的是初始化为没有访问，初始化为0；
        int cnt=0;//表示的是总共有多少个连通块。。。
        if(m<n-1)return -1;//直接返回-1,因为边小于结点数-1，那么无论如何都组不成连通图。。。
        for(int i=0;i<m;i++){
            E[connections[i][0]].push_back(connections[i][1]);
            E[connections[i][1]].push_back(connections[i][0]);
        }
        for(int i=0;i<n;i++){
            if(vis[i]==0){
                dfs(i,vis);
                cnt++;
            }
        }//这样就求出了连通图的数量。。。
        return cnt-1;
    }
};

1320. 二指输入的的最小距离

int dp[350][27][27];//dp[i][j][k]表示的是在第i个位置上，第一个手指的字符为j,第二个手指的字符为K
int n;
const int maxn=10086;
class Solution {
public:
    //先写一个代价函数，求出相应的代价的.
    int Cost(int a,int b){
        //if(a==26||b==26)return 0;
        return abs(a/6-b/6)+abs(a%6-b%6);
    }
    int minimumDistance(string word) {
        memset(dp,maxn,sizeof(dp));
        n=word.length();
        for(int i=0;i<26;i++){
            for(int j=0;j<26;j++){
                dp[0][i][j]=0;//初始化将第0个位置不放元素这个是为了方便之后的操作。。。方便后面dp操作
            }
        }
        for(int i=1;i<=n;i++){
            int m=word[i-1]-'A';//我们都是从阿拉伯数字开始算起的
            for(int j=0;j<26;j++){
                for(int k=0;k<26;k++){
                    if(dp[i-1][j][k]!=maxn){
                        dp[i][m][k]=min(dp[i-1][j][k]+Cost(j,m),dp[i][m][k]);
                        dp[i][j][m]=min(dp[i-1][j][k]+Cost(k,m),dp[i][j][m]);//为什么可能是本身.
                        //因为有可能两个单词相同。
                    }
                }
            }
        }
        int min_num=maxn;
        for(int i=0;i<26;i++){
            for(int j=0;j<26;j++){
                if(dp[n][i][j]!=maxn){
                    min_num=min(min_num,dp[n][i][j]);
                }
            }
        }
        return min_num;

    }
};