2020牛客暑期多校训练营（第五场） FIE补题报告

F：按照题意输出所有人的伤害柱形图，并用星号标出mvp（伤害最高的人），厂长4396虎2200风评被害。

注意0伤害不要输出多余空格。

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 150;
int a[maxn];
double l[maxn];
int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int n;
	cin >> n;
	int maxx = 0;
	for(int i = 1; i <= n; i++)
	{
		cin >> a[i];
		maxx = max(maxx,a[i]);
	}
	for(int i = 1; i <= n; i++)
	{
		l[i] = 50 * (double)a[i] / maxx;
		if(l[i] > (int)l[i])
		{
			l[i] = (int)l[i] + 1;
		}
	}
	for(int i = 1; i <= n; i++)
	{
		cout << "+";
		for(int j = 1; j <= l[i]; j++)
		{
			cout << '-';
		}
		cout << "+" << endl;
		cout << "|";
		for(int j = 1; j < l[i]; j++)
		{
			cout << " ";
		}
		if(a[i] == maxx) cout << "*";
		else if(l[i] > 0) cout << " ";
		cout << "|";
		cout << a[i] << endl;
		cout << "+";
		for(int j = 1; j <= l[i]; j++)
		{
			cout << '-';
		}
		cout << "+" << endl;
	}
	return 0;
}

I：有总部A和两种机器BC，每一个总部A必须与一个B和一个C相邻，问在无穷大的nm矩阵内，总部A最多的数目num / （nm）。

队友直接猜的2/3，神奇。0.666667！！！！
这里采用我自己的理解，过多的证明太繁琐

由ABC形成三条斜线，斜线无限长。
那么A的数目 等于BC数目的两倍，占2/3
无限大的n*m可以视为由无线条这样的斜线构成，所以也是2/3.

E：给你多个映射用于交换，问最多可以出现多少个不同的序列

求所有环的lcm。
需要使用大数，因为最后的结果的会超过longlong
最后的结果一定小于10的n次方，省去取模操作。

#include<iostream>
#include<sstream>
#include<algorithm>
#include<cstring>
#include<iomanip>
#include<vector>
#include<cmath>
#include<ctime>
#include<stack>
#include<map>
using namespace std;
struct Wint:vector<int>//用标准库vector做基类，完美解决位数问题，同时更易于实现
{
    //将低精度转高精度的初始化，可以自动被编译器调用
    //因此无需单独写高精度数和低精度数的运算函数，十分方便
    Wint(int n=0)//默认初始化为0，但0的保存形式为空
    {
        push_back(n);
        check();
    }
    Wint& check()//在各类运算中经常用到的进位小函数，不妨内置
    {
        while(!empty()&&!back())pop_back();//去除最高位可能存在的0
        if(empty())return *this;
        for(int i=1; i<size(); ++i)//处理进位
        {
            (*this)[i]+=(*this)[i-1]/10;
            (*this)[i-1]%=10;
        }
        while(back()>=10)
        {
            push_back(back()/10);
            (*this)[size()-2]%=10;
        }
        return *this;//为使用方便，将进位后的自身返回引用
    }
};
//输入输出
istream& operator>>(istream &is,Wint &n)
{
    string s;
    is>>s;
    n.clear();
    for(int i=s.size()-1; i>=0; --i)n.push_back(s[i]-'0');
    return is;
}
ostream& operator<<(ostream &os,const Wint &n)
{
    if(n.empty())os<<0;
    for(int i=n.size()-1; i>=0; --i)os<<n[i];
    return os;
}
//比较，只需要写两个，其他的直接代入即可
//常量引用当参数，避免拷贝更高效
bool operator!=(const Wint &a,const Wint &b)
{
    if(a.size()!=b.size())return 1;
    for(int i=a.size()-1; i>=0; --i)
        if(a[i]!=b[i])return 1;
    return 0;
}
bool operator==(const Wint &a,const Wint &b)
{
    return !(a!=b);
}
bool operator<(const Wint &a,const Wint &b)
{
    if(a.size()!=b.size())return a.size()<b.size();
    for(int i=a.size()-1; i>=0; --i)
        if(a[i]!=b[i])return a[i]<b[i];
    return 0;
}
bool operator>(const Wint &a,const Wint &b)
{
    return b<a;
}
bool operator<=(const Wint &a,const Wint &b)
{
    return !(a>b);
}
bool operator>=(const Wint &a,const Wint &b)
{
    return !(a<b);
}
//加法，先实现+=，这样更简洁高效
Wint& operator+=(Wint &a,const Wint &b)
{
    if(a.size()<b.size())a.resize(b.size());
    for(int i=0; i!=b.size(); ++i)a[i]+=b[i];
    return a.check();
}
Wint operator+(Wint a,const Wint &b)
{
    return a+=b;
}
//减法，返回差的绝对值，由于后面有交换，故参数不用引用
Wint& operator-=(Wint &a,Wint b)
{
    if(a<b)swap(a,b);
    for(int i=0; i!=b.size(); a[i]-=b[i],++i)
        if(a[i]<b[i])//需要借位
        {
            int j=i+1;
            while(!a[j])++j;
            while(j>i)
            {
                --a[j];
                a[--j]+=10;
            }
        }
    return a.check();
}
Wint operator-(Wint a,const Wint &b)
{
    return a-=b;
}
//乘法不能先实现*=，原因自己想
Wint operator*(const Wint &a,const Wint &b)
{
    Wint n;
    n.assign(a.size()+b.size()-1,0);
    for(int i=0; i!=a.size(); ++i)
        for(int j=0; j!=b.size(); ++j)
            n[i+j]+=a[i]*b[j];
    return n.check();
}
Wint& operator*=(Wint &a,const Wint &b)
{
    return a=a*b;
}
//除法和取模先实现一个带余除法函数
Wint divmod(Wint &a,const Wint &b)
{
    Wint ans;
    for(int t=a.size()-b.size(); a>=b; --t)
    {
        Wint d;
        d.assign(t+1,0);
        d.back()=1;
        Wint c=b*d;
        while(a>=c)
        {
            a-=c;
            ans+=d;
        }
    }
    return ans;
}
Wint operator/(Wint a,const Wint &b)
{
    return divmod(a,b);
}
Wint& operator/=(Wint &a,const Wint &b)
{
    return a=a/b;
}
Wint& operator%=(Wint &a,const Wint &b)
{
    divmod(a,b);
    return a;
}
Wint operator%(Wint a,const Wint &b)
{
    return a%=b;
}
//顺手实现一个快速幂，可以看到和普通快速幂几乎无异
/*Wint pow(const Wint &n,const Wint &k)
{
    if(k.empty())return 1;
    if(k==2)return n*n;
    if(k.back()%2)return n*pow(n,k-1);
    return pow(pow(n,k/2),2);
}*/
const int maxn = 1e5 + 50;
int p[maxn];
int vis[maxn] = {0};
vector<int> v;
void dfs(int x, int num)
{
    vis[x] = 1;
    if(!vis[p[x]])
    {
        num++;
        dfs(p[x],num);
    }
    else
    {
        v.push_back(num);
        return ;
    }
}
Wint gcd(Wint a,Wint b)
{
    return b == 0 ? a : gcd(b, a % b);
}
map<int,int> num;
int main()
{
    int n;
    cin >> n;
    for(int i = 1; i <= n; i++)
    {
        cin >> p[i];
    }
    for(int i = 1; i <= n; i++)
    {
        dfs(i,1);
    }
    for(int i = 0; i < v.size(); i++)
    {
    	int j;
    	int a = v[i];
    	for( j = 2; j*j <= v[i]; j+=1)
    	{
    		int cnt = 0;
    		while(a % j == 0)
    		{
    			a /= j;
    			cnt+=1;
			}
			num[j] = max(cnt,num[j]);
		}
		int t = 1;
		if(a > 1) num[a] = max(t,num[a]);
	//	
	}
	//cout << "执行2" << endl;
	
    Wint ans = 1;
    for(int i = 2; i <= n; i++)
    {
    	ans *= pow(i,num[i]);
    //	cout << "执行" << endl;
	}
	//cout << ans << endl;
	Wint t = 10;
   // Wint mod = pow(t,n);
    //cout << mod << endl;
    cout << ans << endl;
    return 0;
}

预计补题D
还需要找一个可以用的大数模板