codeforces B - Balanced Fighters

题目链接

 

5小时的自闭基本4小时送给它了，过了以后才发现。。。这真的是签到题啊55555

 

翻译题意，讲的就是有很多骑士，三个人分别挑选其中三个骑士A,B,C。用"->"表示击败，A,B,C构成A->B->C->A，或者A->C->B->A。类似于一个环，可以从A往两边出发。

 

整理一下思路，题目中最多有100个样例，所以可以暴力通过（所以为什么这个菜鸡暴力都不会写啊喂）

 

方法一：用整数相除判断回合，如果有余数的话，在结果的基础上+1。

#include <bits/stdc++.h>  
using namespace std;  
#define up(i,x,y) for(int i=x;i<y;i++)  
#define down(i,x,y) for(int i=x;i>=y;i--)  
#define MEM(a,x) memset(a,x,sizeof(a))   
#define ll long long  
#define N 1000005  
#define MOD 1000000007  
#define INF 0x3f3f3f3f  
#define EXP 1e-8  

const int maxn = 1e6 + 10;

struct fighter{
    char ch[20];
    int hp,at,df;
} f[110];//骑士的个数，相关信息存在结构体中 


struct count
{
    int a,b,c;
} cou[maxn];//记录可行的方案内容，abc分别为不同的骑士 

int pan(int i, int j)
{
    int c = max(f[i].at - f[j].df, 0);//f[i]每回合受到的伤害 
    int d = max(f[j].at - f[i].df, 0); //f[j]每回合受到的伤害 
    if(c == d && c == 0 || c == 0) return 0;//c为0时，f[j]永远不会失败 
    else if(d == 0) return 1;//d为0且c不为0时，f[i]必胜 
    else
    {
        if(f[i].hp % d) d = f[i].hp / d + 1;//如果有余数，则坚持的回合+1 
        else d = f[i].hp / d; 
        if(f[j].hp % c) c = f[j].hp / c + 1; 
        else c = f[j].hp / c;
        if(d > c) return 1; 
        else return 0;
    }
}
//这部分是判断f[i],f[j]是否满足f[i]->f[j]的关系 

int main()
{
    //ios_base::sync_with_stdio(0);
    //cin.tie(0);
    int t,n,num,x = 0;
    cin >> t;
    up(i,0,t)
    {
        cin >> f[i].ch >> f[i].hp >> f[i].at >> f[i].df;
    }
    up(i,0,t)
    {
        up(j,i + 1,t)
        {
                up(k,j + 1,t)
                {
                    if(pan(i,j) && pan(j,k) && pan(k,i))//判断是否满足题目要求 
                    {
                        cou[x].a = i;
                        cou[x].b = j;
                        cou[x].c = k;
                        x++;     
                    }
                    if(pan(i,k) && pan(k,j) && pan(j,i))//反向判断 
                    {
                        cou[x].a = i;
                        cou[x].b = j;
                        cou[x].c = k;
                        x++; 
                    }
                }
        }
    }
    cout << x << endl;
    up(i,0,x)
    {
        cout << f[cou[i].a].ch << " " << f[cou[i].b].ch << " " << f[cou[i].c].ch << endl;
    }
}

 

 

方法二：用小数相除判断回合，相除结果+0.9996，再转化成整数比较。

#include <bits/stdc++.h>  
using namespace std;  
#define up(i,x,y) for(int i=x;i<y;i++)  
#define down(i,x,y) for(int i=x;i>=y;i--)  
#define MEM(a,x) memset(a,x,sizeof(a))   
#define ll long long  
#define N 1000005  
#define MOD 1000000007  
#define INF 0x3f3f3f3f  
#define EXP 1e-8  

const int maxn = 1e6 + 10;

struct fighter{
    char ch[20];
    int hp,at,df;
} f[110];//骑士的个数，相关信息存在结构体中 


struct count
{
    int a,b,c;
} cou[maxn];//记录可行的方案内容，abc分别为不同的骑士 

int pan(int i, int j)
{
    double c = max(f[i].at - f[j].df, 0);//f[i]每回合受到的伤害 
    double d = max(f[j].at - f[i].df, 0); //f[j]每回合受到的伤害 
    if(c == d && c == 0 || c == 0) return 0;//c为0时，f[j]永远不会失败 
    else if(d == 0) return 1;//d为0且c不为0时，f[i]必胜 
    else
    {
        d = f[i].hp / d + 0.9996;//加上一个接近1的数字 
        c = f[j].hp / c + 0.9996;
        if((int)d > (int)c) return 1;//转成整数判断 
        else return 0;
    }
}
//这部分是判断f[i],f[j]是否满足f[i]->f[j]的关系 

int main()
{
    //ios_base::sync_with_stdio(0);
    //cin.tie(0);
    int t,n,num,x = 0;
    cin >> t;
    up(i,0,t)
    {
        cin >> f[i].ch >> f[i].hp >> f[i].at >> f[i].df;
    }
    up(i,0,t)
    {
        up(j,i + 1,t)
        {
                up(k,j + 1,t)
                {
                    if(pan(i,j) && pan(j,k) && pan(k,i))//判断是否满足题目要求 
                    {
                        cou[x].a = i;
                        cou[x].b = j;
                        cou[x].c = k;
                        x++;     
                    }
                    if(pan(i,k) && pan(k,j) && pan(j,i))//反向判断 
                    {
                        cou[x].a = i;
                        cou[x].b = j;
                        cou[x].c = k;
                        x++; 
                    }
                }
        }
    }
    cout << x << endl;
    up(i,0,x)
    {
        cout << f[cou[i].a].ch << " " << f[cou[i].b].ch << " " << f[cou[i].c].ch << endl;
    }
}