ZOJ 3879(大模拟)

题面:
Capture the Flag

Time Limit: 2 Seconds      Memory Limit: 65536 KB      Special Judge

In computer security, Capture the Flag (CTF) is a computer security competition. CTF contests are usually designed to serve as an educational exercise to give participants experience in securing a machine, as well as conducting and reacting to the sort of attacks found in the real world. Reverse-engineering, network sniffing, protocol analysis, system administration, programming, and cryptanalysis are all skills which have been required by prior CTF contests at DEF CON. There are two main styles of capture the flag competitions: attack/defense and jeopardy.

In an attack/defense style competition, each team is given a machine (or a small network) to defend on an isolated network. Teams are scored on both their success in defending their assigned machine and on their success in attacking other team's machines. Depending on the nature of the particular CTF game, teams may either be attempting to take an opponent's flag from their machine or teams may be attempting to plant their own flag on their opponent's machine.

Recently, an attack/defense style competition called MCTF held byMarjar University is coming, and there are N teams whichparticipate in the competition. In the beginning, each team has Spoints as initial score; during the competition, there are some checkpointswhich will renew scores for all teams. The rules of the competition are asfollows:

  • If a team has been attacked for a service P, they will lose N - 1 points. The lost points will be split equally and be added to the team(s) which attacks successfully. For example, there are 4 teams and Team A has been attacked by Team B and Team C, so Team A will lose 3 points, while Team B and Team C each will get 1.5 points.
  • If a team cannot maintain their service well, they will lose N - 1 points, which will be split equally too and be added to the team(s) which maintains the service well.

The score will be calculated at the checkpoints and then all attacks will be re-calculated. Edward is the organizer of the competition and he needs to write a program to display the scoreboard so the teams can see their scores instantly. But he doesn't know how to write. Please help him!

Input

There are multiple test cases. The first line of input contains an integer T indicating the number of test cases. For each test case:

The first line contains four integers N (2 <= N <= 100) - the number of teams, Q - the number of services (1 <= Q <= 10), S - the initial points (0 <= S <= 100000) and C - the number of checkpoints (1 <= C <= 100).

For each checkpoint, there are several parts:

  • The first line contains an integer A - the number of the successful attacks. Then A lines follow and each line contains a message:
    [The No. of the attacker] [The No. of the defender] [The No. of the service]
    For example, "1 2 3" means the 1st team attacks the 2nd team in service 3 successfully. The No. of teams and services are indexed from 1. You should notice that duplicate messages are invalid because of the rules. Just ignore them.
  • Then there are Q lines and each line contains N integers. The jth number of the ith line indicating the jth team's maintaining status of the ith service, where 1 means well and 0 means not well.
  • Finally there is an integer U (0 <= U <= 100), which describing the number of the queries. The following line contains U integers, which means Edward wants to know the score and the ranking of these teams.

Output

For each query L, output the score and the ranking of the Lth team. The relative error or absolute error of the score should be less than 10-5. The team with higher score gets higher rank; the teams with the same scores should have the same rank. It is guaranteed that the scores of any two teams are either the same or with a difference greater than 10-5.

Sample Input

1
4 2 2500 5
0
1 1 1 1
1 1 1 1
4
1 2 3 4
2
1 2 1
3 2 1
1 1 1 1
1 1 1 1
4
1 2 3 4
1
1 2 2
1 1 1 1
1 1 1 0
4
1 2 3 4
0
0 0 0 0
0 0 0 0
4
1 2 3 4
0
1 1 1 1
1 1 1 1
2
1 4

Sample Output

2500.00000000 1
2500.00000000 1
2500.00000000 1
2500.00000000 1
2501.50000000 1
2497.00000000 4
2501.50000000 1
2500.00000000 3
2505.50000000 1
2495.00000000 4
2502.50000000 2
2497.00000000 3
2499.50000000 1
2489.00000000 4
2496.50000000 2
2491.00000000 3
2499.50000000 1
2491.00000000 3

Hint

For C++ users, kindly use scanf to avoid TLE for huge inputs.

    题目描述:有n个人进行黑客比赛。他们的初始分数为s,他们有Q台机器要进行攻击和防守,要进行C个回个的较量。每个回合互相都可以进行攻击,当第i个人被攻击时,他将会扣除n-1点分数,而攻击第i个人的所有人可以平均分得着n-1点分数。

    每个回合黑客们也要进行对Q个机器的维护,对于第i个机器,第j个人成功维护输入1,未成功维护输入0,未成功维护的人将扣除n-1点分数,这n-1点分数由成功维护好了第i个机器的人所评分。
    最后有U个询问,每个询问有一个输入id输出第id个人的分数和排名。
    

    题目分析:这题就是一个大模拟。(事实上模拟出的难度并不算高(就是题目比较长))。
    理解了题意之后我们可以知道,这道题有三个操作,第一个是要维护攻击时的分数分配。对于这个问题,我们可以开一个三维的vis数组vis[i][j][k],记录第i个人攻击第j个人的第k个服务器,之后枚举即可。
    第二个是要维护维护Q个机器时的分数分配。对于这个问题,因为要统计0和1的个数,我们可以开两个数组记录下0和1的编号即可(也可以用vector去记录,这样方便一些)

    第三个是要维护分数更改后的排名。这个我们可以重载两次sort的运算符(第一次使之按数值的大小降序排序,第二次按id的大小升序排)因为题面要求精度要小于1e-5,所以在排名的时候只要把满足两个数相减小于1e-5的看作相等即可。
    最后保留八位小数输出即可!

    整体上不算难想,就是实现上有点繁琐,对于这种大模拟,估计只能多练了。つ﹏⊂
    代码如下:    
    
#include <bits/stdc++.h>
#define maxn 105
#define ESP 1e-5
using namespace std;
struct name{
    int id;
    double sum;
    int ranks;
}q[maxn];
bool vis[maxn][maxn][maxn];
bool cmp(name a,name b){
    return a.sum>b.sum;
}
bool cmp2(name a,name b){
    return a.id<b.id;
}
int main()
{
    //freopen("in.txt","r",stdin);
    int t;
    scanf("%d",&t);
    while(t--){
        int n,Q,c;
        double s;
        scanf("%d%d%lf%d",&n,&Q,&s,&c);
        for(int i=1;i<=n;i++){
            q[i].id=i;
            q[i].ranks=1;
            q[i].sum=s;
        }
        while(c--){
            int A;
            memset(vis,0,sizeof(vis));
            scanf("%d",&A);
            for(int i=0;i<A;i++){
                int att,def,sef;
                scanf("%d%d%d",&att,&def,&sef);
                vis[att][def][sef]=1;
            }
            for(int i=1;i<=Q;i++){
                for(int j=1;j<=n;j++){
                    int cnt=0;
                    for(int k=1;k<=n;k++){
                        if(vis[k][j][i]) cnt++;
                    }
                    if(!cnt) continue;
                    q[j].sum-=n-1;
                    double add_scr=(n-1)*1.0/cnt;
                    for(int k=1;k<=n;k++){
                        if(vis[k][j][i]) q[k].sum+=add_scr;
                    }
                }
            }
            for(int i=1;i<=Q;i++){
                vector<int> one;
                vector<int> zero;
                for(int j=1;j<=n;j++){
                    int tmp;
                    scanf("%d",&tmp);
                    if(tmp) one.push_back(j);
                    else zero.push_back(j);
                }
                double mins=0;
                for(int j=0;j<zero.size();j++){
                    q[zero[j]].sum-=n-1;
                    mins+=n-1;
                }
                mins=1.0*mins/one.size();
                for(int j=0;j<one.size();j++){
                    q[one[j]].sum+=mins;
                }
            }
            int U;
            scanf("%d",&U);
            sort(q+1,q+1+n,cmp);
            q[1].ranks=1;
            int rankp=1;
            for(int i=2;i<=n;i++){
                rankp++;
                if(q[i-1].sum-q[i].sum<=ESP){
                    q[i].ranks=q[i-1].ranks;
                }
                else q[i].ranks=rankp;
            }
            sort(q+1,q+1+n,cmp2);
            while(U--){
                int x;
                scanf("%d",&x);
                printf("%.8f %d\n",q[x].sum,q[x].ranks);
            }
        }
    }
    return 0;
}

猜你喜欢

转载自blog.csdn.net/weixin_39453270/article/details/80165992
ZOJ