解法1：

import java.util.LinkedList;
import java.util.Queue;

public class SenatorVictory {
    public String predictPartyVictory(String s) {
        int n = s.length();
        Queue<Integer> redQueue = new LinkedList<>();
        Queue<Integer> darkQueue = new LinkedList<>();
        
        // 初始化队列，存储各阵营参议员的索引
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == 'R') {
                redQueue.add(i);
            } else {
                darkQueue.add(i);
            }
        }
        
        // 模拟弹劾过程
        while (!redQueue.isEmpty() && !darkQueue.isEmpty()) {
            int redIndex = redQueue.poll();
            int darkIndex = darkQueue.poll();
            
            // 索引较小的先行动，弹劾对方阵营的下一位，自己进入下一轮
            if (redIndex < darkIndex) {
                redQueue.add(redIndex + n);
            } else {
                darkQueue.add(darkIndex + n);
            }
        }
        
        // 队列非空的阵营获胜
        return redQueue.isEmpty() ? "Dark" : "Red";
    }
}

解法2：

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 求出最终获胜帮派的名称
     * @param s string字符串 包含'R'(红帮)和'D'(黑帮)的字符串
     * @return string字符串 "Red"表示红帮获胜，"Dark"表示黑帮获胜
     */
    public String predictVictory (String s) {
        // 创建队列用于模拟参议员的循环行动顺序
        Queue<Character> queue = new LinkedList<>();

        // 统计初始时黑帮和红帮的参议员数量
        int darknum = 0;  // 黑帮(D)参议员数量
        int rednum = 0;   // 红帮(R)参议员数量
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == 'D') {
                darknum++;
            } else if (c == 'R') {
                rednum++;
            }
            // 将所有参议员按初始顺序加入队列
            queue.offer(c);
        }

        // 记录需要被弹劾的参议员数量
        int darkout = 0;  // 等待被弹劾的黑帮参议员数量
        int redout = 0;   // 等待被弹劾的红帮参议员数量
        
        // 当双方都还有剩余参议员时，继续循环
        while (darknum != 0 && rednum != 0) {
            // 取出当前行动的参议员
            char front = queue.poll();

            // 处理黑帮参议员的行动
            if (front == 'D') {
                // 如果当前黑帮参议员不需要被弹劾
                if (darkout == 0) {
                    // 选择弹劾一名红帮参议员
                    redout++;
                    // 自己进入下一轮循环
                    queue.offer(front);
                    // 红帮剩余数量减一
                    rednum--;
                } else {
                    // 当前黑帮参议员被弹劾，减少待弹劾计数
                    darkout--;
                }
            } 
            // 处理红帮参议员的行动
            else if (front == 'R') {
                // 如果当前红帮参议员不需要被弹劾
                if (redout == 0) {
                    // 选择弹劾一名黑帮参议员
                    darkout++;
                    // 自己进入下一轮循环
                    queue.offer(front);
                    // 黑帮剩余数量减一
                    darknum--;
                } else {
                    // 当前红帮参议员被弹劾，减少待弹劾计数
                    redout--;
                }
            }
        }

        // 根据剩余数量判断获胜阵营
        if (darknum == 0) {
            return "Red";
        }
        if (rednum == 0) {
            return "Dark";
        }
        // 理论上不会执行到这里，用于处理异常情况
        return "Error";
    }
}