使用队列的Java算法题

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

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

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

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

给定一个字符串代表每个参议员的阵营。字母 “R” 和 “D” 分别代表了Radiant（天辉）和Dire（夜魇）。
然后，如果有 n 个参议员，给定字符串的大小将是n。
以轮为基础的过程从给定顺序的第一个参议员开始到最后一个参议员结束。
这一过程将持续到投票结束。所有失去权利的参议员将在过程中被跳过。
假设每一位参议员都足够聪明，会为自己的政党做出最好的策略，
你需要预测哪一方最终会宣布胜利并在 Dota2 游戏中决定改变。输出应该是Radiant或Dire。


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

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

我一开始的想法是使用两个数nd nr来记录两方的人数，用一个数k来记录当前行使权力的人的编号；

使用一个与字符串长度相等的数组保存对应位置人是否失去权力；

一直循环直到有一方人数变为零

代码如下：

public String predictPartyVictory(String senate) {
        int length = senate.length();
        char[] chars = senate.toCharArray();
        boolean[] flags = new boolean[length];
        for (int i = 0; i < length; i++) {
            flags[i]=true;
        }
        int id =0; //记录两个指针
        int nd =0, nr = 0;//记录两种人的个数
        int k=0;
        while (k<length){
            if (chars[k]=='D')nd++;
            if (chars[k]=='R')nr++;
            k++;
        }
        if (nd==0){
            return "Radiant";
        }else if (nr==0){
            return "Dire";
        }
        k=0;
        while (nd>0&&nr>0){
            if (k==length-1){
                id = 0;
            }else {
                id = k+1;
            }
            if (chars[k]=='R'){
                while (!flags[id]||chars[id]=='R'){//寻找下一个有效对手 并消灭
                    if (id==length-1)id=0;
                    else id++;
                }
                flags[id] = false;
                nd--;
            }
            else {
                while (!flags[id]||chars[id]=='D'){
                    if (id==length-1)id=0;
                    else id++;
                }
                flags[id] = false;
                nr--;
            }
            if (k==length-1)k=0;
            else k++;//轮回
            while (!flags[k]){//寻找下一个有效的选举人
                if (k==length-1){
                    k=0;
                }else {
                    k++;
                }
            }
        }
        if (nd==0){
            return "Radiant";
        }else {
            return "Dire";
        }
    }

但是这代码有一个明显的缺点，每次寻找下一个未失去权力的人 都会遍历n的长度，中间经过一些失去权力的人，消耗时间。

标准答案上使用两个队列来进行pk，行使权力的人 出队后权重加n后重新进入队列，失去权力的人永久出队。

public String predictPartyVictory(String senate) {
        int n = senate.length();
        Queue<Integer> radiant = new LinkedList<Integer>();
        Queue<Integer> dire = new LinkedList<Integer>();
        for (int i = 0; i < n; ++i) {
            if (senate.charAt(i) == 'R') {
                radiant.offer(i);
            } else {
                dire.offer(i);
            }
        }
        while (!radiant.isEmpty() && !dire.isEmpty()) {
            int radiantIndex = radiant.poll(), direIndex = dire.poll();
            if (radiantIndex < direIndex) {
                radiant.offer(radiantIndex + n);
            } else {
                dire.offer(direIndex + n);
            }
        }
        return !radiant.isEmpty() ? "Radiant" : "Dire";
    }

还是要善于利用数据结构。。。