1947. 最大兼容性评分和 周赛 力扣（中等） 排列next_permutation用法

1947. 最大兼容性评分和

有一份由 n 个问题组成的调查问卷，每个问题的答案要么是 0（no，否），要么是 1（yes，是）。

这份调查问卷被分发给 m 名学生和 m 名导师，学生和导师的编号都是从 0 到 m - 1 。学生的答案用一个二维整数数组 students 表示，其中 students[i] 是一个整数数组，包含第 i 名学生对调查问卷给出的答案（下标从 0 开始）。导师的答案用一个二维整数数组 mentors 表示，其中 mentors[j] 是一个整数数组，包含第 j 名导师对调查问卷给出的答案（下标从 0 开始）。

每个学生都会被分配给 一名 导师，而每位导师也会分配到 一名 学生。配对的学生与导师之间的兼容性评分等于学生和导师答案相同的次数。

例如，学生答案为[1, 0, 1] 而导师答案为 [0, 0, 1] ，那么他们的兼容性评分为 2 ，因为只有第二个和第三个答案相同。
请你找出最优的学生与导师的配对方案，以 最大程度上 提高 兼容性评分和 。

给你 students 和 mentors ，返回可以得到的 最大兼容性评分和 。

示例 1：

输入：students = [[1,1,0],[1,0,1],[0,0,1]], mentors = [[1,0,0],[0,0,1],[1,1,0]]
输出：8
解释：按下述方式分配学生和导师：
- 学生 0 分配给导师 2 ，兼容性评分为 3 。
- 学生 1 分配给导师 0 ，兼容性评分为 2 。
- 学生 2 分配给导师 1 ，兼容性评分为 3 。
最大兼容性评分和为 3 + 2 + 3 = 8 。

题源：https://leetcode-cn.com/problems/maximum-compatibility-score-sum/

学习点：

next_permutation（数组头地址，数组尾地址);
对数组：使用 , +l

int main()
{
    int num = 1,a[6]= {1,2,3,4,5};
    while(next_permutation(a,a+5))
    {
        for(int i=0; i<5; i++)
            cout<<a[i]<<" ";
        if(num==5)
            break;
        num++;
        cout<<endl;
    }
    return 0;
}

对字符串：使用 .begin()和 .end()

int main()
{
    string str = "abcde";
    int num = 1;
    while(next_permutation(str.begin(),str.end()))   
    {
        num++;
        cout<<str<<endl;
        if(num==5)
            break;
    }
    return 0;
}

对容器：

class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> ret;
        sort(begin(nums), end(nums)); // 或者nums.begin()  nums.end()
        do {
            ret.emplace_back(nums);
        } while (next_permutation(begin(nums), end(nums)));   //  nums.begin() nums.end()
        return ret;
    }
};

代码：

class Solution {
public:
    /*struct node
    {
        int stu,men,score;
        node(int a,int b,int c) {stu=a; men=b; score=c;}
    };
    struct cmp
    {
        bool operator()(node a, node b)
        {
            return a.score<b.score;
        }
    };*/
    int maxCompatibilitySum(vector<vector<int>>& students, vector<vector<int>>& mentors) {
     int m=students.size();
     int n=students[0].size();
     /*vector<>
     priority_queue<node,vector<node>,cmp> Q;
     cout<<"--------------------"<<endl;
     for(int i=0;i<m;i++)
         for(int j=0;j<m;j++)
         {
             int sim=0;
             for(int k=0;k<n;k++)
             if(students[i][k]==mentors[j][k]) sim++;
             Q.push(node(i,j,sim));
            
         }

     bool fs[15];
     bool fm[15];
     memset(fs,0,sizeof(fs));
     memset(fm,0,sizeof(fm));
     int res=0;
     while(!Q.empty())
     {
         node p=Q.top();
         Q.pop();
         cout<<p.stu<<" "<<p.men<<" "<<p.score<<endl;
         if(fs[p.stu] || fm[p.men]) continue;
         
         res+=p.score;
         fs[p.stu]=1;
         fm[p.men]=1;
         cout<<"choose"<<endl;
         bool flag=true;
         for(int i=0;i<m;i++)
             if(!fs[i]) flag=false;
         if(flag) break;
     }
        return res;*/  
     int d[15][15];
    
     for(int i=0;i<m;i++)
         for(int j=0;j<m;j++)
         {
             int sim=0;
             for(int k=0;k<n;k++)
             if(students[i][k]==mentors[j][k]) sim++;
             d[i][j]=sim;
         }
    int num[15];
    int res=0;
    for(int i=0;i<m;i++) num[i]=i;  //  从小到大排列，
    do  
    {  
        int sum=0;
        for(int i=0;i<m;i++)  
            sum+=d[i][num[i]];
        res=max(res,sum);
    }while(next_permutation(num,num+m));    //next_permutation(数组头地址，数组尾地址);
        return res;
    }
};