Voting-一道题来看set效率和queue效率

题目是Codeforces Round #388 (Div. 2) 的C题

分析：策略是采取先deny第一个后于自己位置的对手，如果自己后面没对手了就投剩下的对手中位置最靠前的，道理显而易见，位置越前越有可能deny自己阵容的人，肯定要先“让他说不了话”比较合理

一开始直接数组模拟，while（1）遍历数组居然还能过前20多组数据，但这样效率奇低，后来想用优先队列（最小堆），每次把对面的根节点deny，但这样不能保证是最优，例如样test21的数据
7
RDRDDRD
这样写WA，原因是第三个D选择deny的是第一个R而不是紧跟他的下一个R ，这显然坑队友，第四个D会被第三个R搞死（deny）,

//WA 21 的版本
#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
const int maxn = 200005;
char s[maxn];
priority_queue<int,vector<int>,greater<int> > d,r;
int a[maxn]={0},b[maxn]={0};
int main()
{
    int n;
    scanf("%d",&n);
    scanf("%s",s);
    int i=0;
    for(i=0;i<n;++i){
        if(s[i]=='D'){
            d.push(i);
            a[i]=1;
        }
        else {
            r.push(i);
            b[i]=1;
        }
    }

    i = -1;
    while(1){
        if(++i>n)i=0;
        if(d.size()==0){
            puts("R");
            return 0;
        }
        if(r.size()==0){                
            puts("D");
            return 0;
        }

        if(a[i]){//D        
            b[r.top()]=0;
            //printf("%d\n",r.top());
            r.pop();
        }
        else if(b[i]){//R
            a[d.top()]=0;;
            //printf("%d\n",d.top());
            d.pop();
        }   
    }
    return 0;
}

考虑到队列没查找二分搜索之类的，我糊里糊涂地用set做了，以为二分搜索，查找和删除的复杂度是O（logN）时间会过，于是写了下面这个版本
,仔细想一下其实肯定TLE啦，整个复杂度几乎是O（n! *logN）

//TLE 12版本
#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
using namespace std;
const int maxn = 200050;
char s[maxn];
int d[maxn]={0},r[maxn]={0};
set<int> de,re;
int main()
{
    int n;
    scanf("%d",&n);
    scanf("%s",s+1);

    int i = 0;
    for(i=1;i<=n;++i){
        if(s[i]=='D'){
            d[i]=1;
            de.insert(i);
        }else{
            r[i]=1;
            re.insert(i);
        }
    }

    i = 0;
    set<int>::iterator p;
    while(1){
        if(++i > n)i=1;
        if(re.size()==0){
            puts("D");
            return 0;
        }
        if(de.size()==0){
            puts("R");
            return 0;
        }

        if(r[i]){

            p = lower_bound(de.begin(),de.end(),i);
            if(p != de.end()){
                d[ *p ] = 0;
                de.erase(p);
            }else{
                if(de.size()>0){
                    d[ *de.begin() ] = 0;
                    de.erase(de.begin());
                }
            }   
        }else if(d[i]){

            p = lower_bound(re.begin(),re.end(),i);
            if(p != re.end()){
                r[ *p ] = 0;
                re.erase(p);
            }else{
                if(re.size()>0){
                    r[ *re.begin() ] = 0;
                    re.erase(re.begin());
                }
            }   
        }   
    }

    return 0;
}

其实这题想明白一点就能做了，两队分别用两个队列存vote的时间，显然队首小的先投，肯定是投死对面队首的比较有利，然后自己加入回队尾，注意加入队尾时时间要加n轮，代表自己投死对面队首后隔n轮才能再投（如果还合法的话），那会不会对手把自己投死但自己还在队列中这种情况出现呢？显然不会，因为是理智的，所以肯定都会先投对面队首的，如果你出现在队首说明对手对你的队伍的选择优先的只有你了，即你出现就是合理的
想明白就很好写了，时间31ms

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
const int maxn = 200050;
char s[maxn];
queue<int> de,re;
int main()
{
    int n;
    scanf("%d",&n);
    scanf("%s",s+1);

    for(int i=1;i<=n;++i){
        if(s[i]=='D')
            de.push(i);
        else
            re.push(i);
    }   
    while(1){       
        if(re.empty()){
            puts("D");
            return 0;
        }
        if(de.empty()){
            puts("R");
            return 0;
        }
        if(de.front() < re.front()){//D votes
            re.pop();
            de.push(de.front()+n);
            de.pop();
        }else{//R votes
            de.pop();
            re.push(re.front()+n);
            re.pop();
        }
    }
    return 0;
}