649. Dota2 参议院

描述：

Dota2 的世界里有两个阵营：Radiant(天辉)和 Dire(夜魇)

Dota2 参议院由来自两派的参议员组成。现在参议院希望对一个 Dota2 游戏里的改变作出决定。他们以一个基于轮为过程的投票进行。在每一轮中，每一位参议员都可以行使两项权利中的一项：

禁止一名参议员的权利：

参议员可以让另一位参议员在这一轮和随后的几轮中丧失所有的权利。

宣布胜利：如果参议员发现有权利投票的参议员都是同一个阵营的，他可以宣布胜利并决定在游戏中的有关变化。

给定一个字符串代表每个参议员的阵营。字母 “R” 和 “D” 分别代表了 Radiant（天辉）和 Dire（夜魇）。然后，如果有 n 个参议员，给定字符串的大小将是 n。

以轮为基础的过程从给定顺序的第一个参议员开始到最后一个参议员结束。这一过程将持续到投票结束。所有失去权利的参议员将在过程中被跳过。

假设每一位参议员都足够聪明，会为自己的政党做出最好的策略，你需要预测哪一方最终会宣布胜利并在 Dota2 游戏中决定改变。输出应该是 Radiant 或 Dire。

示例 1:

输入: "RD"
输出: "Radiant"
解释: 第一个参议员来自 Radiant 阵营并且他可以使用第一项权利让第二个参议员失去权力，因此第二个参议员将被跳过因为他没有任何权利。然后在第二轮的时候，第一个参议员可以宣布胜利，因为他是唯一一个有投票权的人
示例 2:

输入: "RDD"
输出: "Dire"
解释:
第一轮中,第一个来自 Radiant 阵营的参议员可以使用第一项权利禁止第二个参议员的权利
第二个来自 Dire 阵营的参议员会被跳过因为他的权利被禁止
第三个来自 Dire 阵营的参议员可以使用他的第一项权利禁止第一个参议员的权利
因此在第二轮只剩下第三个参议员拥有投票的权利,于是他可以宣布胜利

注意:

给定字符串的长度在 [1, 10,000] 之间.

 1 解法1：    112 ms    9 MB
 2 class Solution {
 3 public:
 4     string predictPartyVictory(string senate) {
 5         /*思路：
 6             1:对每个字符统计个数
 7             2:只要是从头开始遍历的，那么，禁止后面的 对方阵营的，这样才能保证最优
 8             3:相互禁止
 9             4:最后判断第一个是谁 就可以了
10         */
11        while(!senate.empty()){
12             char pre=senate[0];//pre代表先 前是什么阵营的
13             int cnt=1;
14             for(int i=1;i<senate.size();i++){//遍历
15                 if(senate[i]==pre){//当前阵营的 和 先前阵营的 一样
16                     cnt++;//禁用 另一方的 个数 加1
17                 }else{// 若是不一样
18                     if(cnt==0) {//cnt=0 表明 ，另一方不能再禁用了，从新的一方开始，继续遍历
19                         cnt=1;
20                         pre=senate[i];//更新 pre
21                     }
22                     else{//若cnt>0 那么表明前面的 另一方 可以禁用 本方 的权利
23                         senate[i]=' ';//赋值为空
24                         cnt--;//个数减1
25                     }
26                 }
27             }
28             if(cnt!=0){//若是还有剩余 说明 还是可以禁用另一方的
29                 for(int i=0;i<senate.size();i++){//可能 最后 cnt还有剩余 遍历
30                     if(senate[i]!=pre&&senate[i]!=' ') {//从头头开始遍历，删除 和 pre阵营 不一样的
31                         senate[i]=' ';
32                         cnt--;
33                         if(cnt==0) break;//删除够了，跳出 ，进行下一次轮的 循环删除
34                     }
35                 }
36             }
37             for(int i=0;i<senate.size();i++){//将空的  删除
38                 if(senate[i]==' '){
39                     senate.erase(i,1);
40                     i--;//恢复删除空格的这一位置 
41                 } 
42             }
43             if(cnt!=0) break;//若全是一样的，删除完另一方的，本方还有剩余         
44         }
45         return senate[0]=='R'?"Radiant":"Dire";
46     }
47 };

 1 解法2：112 ms    8.7 MB
 2 class Solution {
 3 public:
 4     string predictPartyVictory(string senate) {
 5         /*思路：
 6             1:对每个字符统计个数
 7             2:只要是从头开始遍历的，那么，禁止后面的 对方阵营的，这样才能保证最优
 8             3:相互禁止
 9             4:最后判断第一个是谁 就可以了
10         */
11         bool flagD=true,flagR=true;
12         int personNum=0;//能禁止另一方的人数 >0:R能禁止D;<0:D能禁止R
13         while(flagR&&flagD){//如果两方阵营都还有人
14             flagR=false,flagD=false;//新开始的一轮
15             for(int i=0;i<senate.size();i++){
16                 if(senate[i]=='R'){
17                     flagR=true;//标记R阵营 还有人
18                     if(personNum<0){// 表明D能禁止R
19                         senate.erase(i,1);//删除这个 R;
20                         i--;//恢复
21                     }
22                     personNum++;//人数加1，
23                 }else{
24                     flagD=true;//标记D阵营 还有人
25                     if(personNum>0){// 大于0 ，表明 R能禁止D
26                         senate.erase(i,1);//删除这个D
27                         i--;
28                     }
29                     personNum--;//个数减1
30                 }
31             }
32         }
33         return personNum>0?"Radiant":"Dire";
34     }
35 };

 1 解法3：    8 ms    8.8 MB
 2 //使用赋值 明显比 删除 快多了
 3 class Solution {
 4 public:
 5     string predictPartyVictory(string senate) {
 6         /*思路：
 7             1:对每个字符统计个数
 8             2:只要是从头开始遍历的，那么，禁止后面的 对方阵营的，这样才能保证最优
 9             3:相互禁止
10             4:最后判断第一个是谁 就可以了
11         */
12         bool flagD=true,flagR=true;
13         int personNum=0;//能禁止另一方的人数 >0:R能禁止D;<0:D能禁止R
14         while(flagR&&flagD){//如果两方阵营都还有人
15             flagR=false,flagD=false;//新开始的一轮
16             for(int i=0;i<senate.size();i++){
17                 if(senate[i]=='R'){
18                     flagR=true;//标记R阵营 还有人
19                     if(personNum<0){// 表明D能禁止R
20                         senate[i]=' ';//
21                     }
22                     personNum++;//人数加1，
23                 }else if(senate[i]=='D'){
24                     flagD=true;//标记D阵营 还有人
25                     if(personNum>0){// 大于0 ，表明 R能禁止D
26                        senate[i]=' ';
27                     }
28                     personNum--;//个数减1
29                 }
30             }
31         }
32         return personNum>0?"Radiant":"Dire";
33     }
34 };