标签：Provincial Multi const Contest int typedef queue lld define

宁夏邀请赛的题，网络赛出锅之后来补了一下，还蛮有意思。题目地址：https://codeforces.com/gym/102222

A、给你一个栈和一堆pop、push操作，每次操作之后询问栈中的最大值，如果栈为空输出0

输入是给定的一个随机数生成器

每一次有元素进栈就把他与当前最大值比较，更新最大值之后把最大值压入另一个栈，pop时两个栈同时操作，每次输出另一个栈的栈顶即可

（这就是单调栈？）

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

int t,n,p,q,m,Case=1;
unsigned int SA,SB,SC;
stack<unsigned int> mx;
ll ans;

unsigned int rng61(){
    SA^=SA<<16;
    SA^=SA>>5;
    SA^=SA<<1;
    unsigned int t=SA;
    SA=SB;
    SB=SC;
    SC^=t^SA;
    return SC;
}

void Push(unsigned int v){
    if(mx.empty()) mx.push(v);
    else mx.push(max(mx.top(),v));
}

void Pop(){
    if(mx.empty()) return;
    mx.pop();
}

void gen(){
    ans=0;
    scanf("%d%d%d%d%u%u%u",&n,&p,&q,&m,&SA,&SB,&SC);
    while(!mx.empty()) mx.pop();
    for(int i=1;i<=n;++i){
        if(rng61()%(p+q)<p)
            Push(rng61()%m+1);
        else
            Pop();
        if(!mx.empty()) ans^=((ll)i*mx.top());
    }
    printf("Case #%d: %lld\n",Case,ans);
}

int main(){
    scanf("%d",&t);
    for(;Case<=t;++Case)
        gen();
    return 0;
}

B、给定一个多边形，一开始p[0]到p[1]这条边在一条直线上，然后不断逆时针旋转多边形使得p[i]到p[i+1]这条边落到直线上

当p[0]到p[1]再次落到直线上时停止旋转

问你多边形内的一个点在这个过程中走了多长

假设每一次旋转的弧度为alpha，画个图就能看出来alpha等于pi减去当前线段与下一条线段的夹角，用余弦定理算夹角就完事

如图：

 

 代码：

#include <bits/stdc++.h>
#define int long long
#define sc(a) scanf("%lld",&a)
#define scc(a,b) scanf("%lld %lld",&a,&b)
#define sccc(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)
#define schar(a) scanf("%c",&a)
#define pr(a) printf("%lld",a)
#define fo(i,a,b) for(int i=a;i<b;++i)
#define re(i,a,b) for(int i=a;i<=b;++i)
#define rfo(i,a,b) for(int i=a;i>b;--i)
#define rre(i,a,b) for(int i=a;i>=b;--i)
#define prn() printf("\n")
#define prs() printf(" ")
#define mkp make_pair
#define pii pair<int,int>
#define pub(a) push_back(a)
#define pob() pop_back()
#define puf(a) push_front(a)
#define pof() pop_front()
#define fst first
#define snd second
#define frt front()
#define bak back()
#define mem0(a) memset(a,0,sizeof(a))
#define memmx(a) memset(a,0x3f3f,sizeof(a))
#define memmn(a) memset(a,-0x3f3f,sizeof(a))
#define debug
#define db double
#define yyes cout<<"YES"<<endl;
#define nno cout<<"NO"<<endl;
using namespace std;
typedef vector<int> vei;
typedef vector<pii> vep;
typedef map<int,int> mpii;
typedef map<char,int> mpci;
typedef map<string,int> mpsi;
typedef deque<int> deqi;
typedef deque<char> deqc;
typedef priority_queue<int> mxpq;
typedef priority_queue<int,vector<int>,greater<int> > mnpq;
typedef priority_queue<pii> mxpqii;
typedef priority_queue<pii,vector<pii>,greater<pii> > mnpqii;
const int maxn=500005;
const int inf=0x3f3f3f3f3f3f3f3f;
const int MOD=100000007;
const db eps=1e-10;
const db pi=3.1415926535;
int qpow(int a,int b){int tmp=a%MOD,ans=1;while(b){if(b&1){ans*=tmp,ans%=MOD;}tmp*=tmp,tmp%=MOD,b>>=1;}return ans;}
int lowbit(int x){return x&-x;}
int max(int a,int b){return a>b?a:b;}
int min(int a,int b){return a<b?a:b;}
int mmax(int a,int b,int c){return max(a,max(b,c));}
int mmin(int a,int b,int c){return min(a,min(b,c));}
void mod(int &a){a+=MOD;a%=MOD;}
bool chk(int now){}
int half(int l,int r){while(l<=r){int m=(l+r)/2;if(chk(m))r=m-1;else l=m+1;}return l;}
int ll(int p){return p<<1;}
int rr(int p){return p<<1|1;}
int mm(int l,int r){return (l+r)/2;}
int lg(int x){if(x==0) return 1;return (int)log2(x)+1;}
bool smleql(db a,db b){if(a<b||fabs(a-b)<=eps)return true;return false;}
db len(db a,db b,db c,db d){return sqrt((a-c)*(a-c)+(b-d)*(b-d));}
bool isp(int x){if(x==1)return false;if(x==2)return true;for(int i=2;i*i<=x;++i)if(x%i==0)return false;return true;}

int t,n,Case=1;
struct point{
    db x,y;
}p[maxn],q;

db len(point a,point b){
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}

signed main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    sc(t);
    for(;Case<=t;++Case){
        db ans=0.0;
        sc(n);
        re(i,0,n-1) scanf("%lf%lf",&p[i].x,&p[i].y);
        p[n]=p[0],p[n+1]=p[1];
        scanf("%lf%lf",&q.x,&q.y);
        re(i,1,n){
            db a=len(p[i-1],p[i]);
            db b=len(p[i],p[i+1]);
            db c=len(p[i-1],p[i+1]);
            db alpha=acos((a*a+b*b-c*c)/(2.0*a*b));
            alpha=pi-alpha;
            ans+=alpha*len(q,p[i]);
        }
        printf("Case #%d: ",Case,ans);
        printf("%.3lf\n",ans);
    }
    return 0;
}

C、给你三个小写字母字符串，第二个字符串是由第一个字符串的每一位加n再对26取余得到的

要求求出n，然后把第三个字符串每一位减n加26再对26取余，输出结果

按照题意搞就行

代码：

#include <bits/stdc++.h>
#define int long long
#define sc(a) scanf("%lld",&a)
#define scc(a,b) scanf("%lld %lld",&a,&b)
#define sccc(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)
#define schar(a) scanf("%c",&a)
#define pr(a) printf("%lld",a)
#define fo(i,a,b) for(int i=a;i<b;++i)
#define re(i,a,b) for(int i=a;i<=b;++i)
#define rfo(i,a,b) for(int i=a;i>b;--i)
#define rre(i,a,b) for(int i=a;i>=b;--i)
#define prn() printf("\n")
#define prs() printf(" ")
#define mkp make_pair
#define pii pair<int,int>
#define pub(a) push_back(a)
#define pob() pop_back()
#define puf(a) push_front(a)
#define pof() pop_front()
#define fst first
#define snd second
#define frt front()
#define bak back()
#define mem0(a) memset(a,0,sizeof(a))
#define memmx(a) memset(a,0x3f3f,sizeof(a))
#define memmn(a) memset(a,-0x3f3f,sizeof(a))
#define debug
#define db double
#define yyes cout<<"YES"<<endl;
#define nno cout<<"NO"<<endl;
using namespace std;
typedef vector<int> vei;
typedef vector<pii> vep;
typedef map<int,int> mpii;
typedef map<char,int> mpci;
typedef map<string,int> mpsi;
typedef deque<int> deqi;
typedef deque<char> deqc;
typedef priority_queue<int> mxpq;
typedef priority_queue<int,vector<int>,greater<int> > mnpq;
typedef priority_queue<pii> mxpqii;
typedef priority_queue<pii,vector<pii>,greater<pii> > mnpqii;
const int maxn=500005;
const int inf=0x3f3f3f3f3f3f3f3f;
const int MOD=100000007;
const db eps=1e-10;
int qpow(int a,int b){int tmp=a%MOD,ans=1;while(b){if(b&1){ans*=tmp,ans%=MOD;}tmp*=tmp,tmp%=MOD,b>>=1;}return ans;}
int lowbit(int x){return x&-x;}
int max(int a,int b){return a>b?a:b;}
int min(int a,int b){return a<b?a:b;}
int mmax(int a,int b,int c){return max(a,max(b,c));}
int mmin(int a,int b,int c){return min(a,min(b,c));}
void mod(int &a){a+=MOD;a%=MOD;}
bool chk(int now){}
int half(int l,int r){while(l<=r){int m=(l+r)/2;if(chk(m))r=m-1;else l=m+1;}return l;}
int ll(int p){return p<<1;}
int rr(int p){return p<<1|1;}
int mm(int l,int r){return (l+r)/2;}
int lg(int x){if(x==0) return 1;return (int)log2(x)+1;}
bool smleql(db a,db b){if(a<b||fabs(a-b)<=eps)return true;return false;}
db len(db a,db b,db c,db d){return sqrt((a-c)*(a-c)+(b-d)*(b-d));}
bool isp(int x){if(x==1)return false;if(x==2)return true;for(int i=2;i*i<=x;++i)if(x%i==0)return false;return true;}

int t,n,m;
string s1,s2,s3;

signed main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    cin>>t;
    re(jj,1,t){
        cin>>n>>m;
        cin>>s1>>s2>>s3;
        int dif=s2[0]-s1[0];
        fo(i,0,m){
            s3[i]=(s3[i]-'A'-dif+26)%26+'A';
        }
        cout<<"Case #"<<jj<<": "<<s3<<endl;
    }
    return 0;
}

H、n只怪物，你对每只怪物的伤害是1、2、3、4，意味着每一次攻击怪物，你对这只怪物的伤害就会增加1

每攻击一次，所有存活的怪物都会对你造成伤害，现在你要挑选一个合适的攻击顺序，使得自己受到的伤害最小

首先考虑对单只怪物，一定要把它打倒再打下一只才更优，应当尽快减少怪物的数量

考虑经典的贪心策略，假设怪物a排在怪物b前面，那么应当满足下面的条件：

杀死怪物a的时间*（怪物a、b的攻击力）+（杀死怪物a、b的时间）*怪物b的攻击力

小于

杀死怪物b的时间*（怪物a、b的攻击力）+（杀死怪物a、b的时间）*怪物a的攻击力

写个排序函数搞一下完事。

代码：

#include <bits/stdc++.h>
#define int long long
#define sc(a) scanf("%lld",&a)
#define scc(a,b) scanf("%lld %lld",&a,&b)
#define sccc(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)
#define schar(a) scanf("%c",&a)
#define pr(a) printf("%lld",a)
#define fo(i,a,b) for(int i=a;i<b;++i)
#define re(i,a,b) for(int i=a;i<=b;++i)
#define rfo(i,a,b) for(int i=a;i>b;--i)
#define rre(i,a,b) for(int i=a;i>=b;--i)
#define prn() printf("\n")
#define prs() printf(" ")
#define mkp make_pair
#define pii pair<int,int>
#define pub(a) push_back(a)
#define pob() pop_back()
#define puf(a) push_front(a)
#define pof() pop_front()
#define fst first
#define snd second
#define frt front()
#define bak back()
#define mem0(a) memset(a,0,sizeof(a))
#define memmx(a) memset(a,0x3f3f,sizeof(a))
#define memmn(a) memset(a,-0x3f3f,sizeof(a))
#define debug
#define db double
#define yyes cout<<"YES"<<endl;
#define nno cout<<"NO"<<endl;
using namespace std;
typedef vector<int> vei;
typedef vector<pii> vep;
typedef map<int,int> mpii;
typedef map<char,int> mpci;
typedef map<string,int> mpsi;
typedef deque<int> deqi;
typedef deque<char> deqc;
typedef priority_queue<int> mxpq;
typedef priority_queue<int,vector<int>,greater<int> > mnpq;
typedef priority_queue<pii> mxpqii;
typedef priority_queue<pii,vector<pii>,greater<pii> > mnpqii;
const int maxn=500005;
const int inf=0x3f3f3f3f3f3f3f3f;
const int MOD=100000007;
const db eps=1e-10;
int qpow(int a,int b){int tmp=a%MOD,ans=1;while(b){if(b&1){ans*=tmp,ans%=MOD;}tmp*=tmp,tmp%=MOD,b>>=1;}return ans;}
int lowbit(int x){return x&-x;}
int max(int a,int b){return a>b?a:b;}
int min(int a,int b){return a<b?a:b;}
int mmax(int a,int b,int c){return max(a,max(b,c));}
int mmin(int a,int b,int c){return min(a,min(b,c));}
void mod(int &a){a+=MOD;a%=MOD;}
bool chk(int now){}
int half(int l,int r){while(l<=r){int m=(l+r)/2;if(chk(m))r=m-1;else l=m+1;}return l;}
int ll(int p){return p<<1;}
int rr(int p){return p<<1|1;}
int mm(int l,int r){return (l+r)/2;}
int lg(int x){if(x==0) return 1;return (int)log2(x)+1;}
bool smleql(db a,db b){if(a<b||fabs(a-b)<=eps)return true;return false;}
db len(db a,db b,db c,db d){return sqrt((a-c)*(a-c)+(b-d)*(b-d));}
bool isp(int x){if(x==1)return false;if(x==2)return true;for(int i=2;i*i<=x;++i)if(x%i==0)return false;return true;}

int t,n;
int Case=1;
vei v;
struct node{
    int hp,atk;
}o[maxn];

bool cmp(node a,node b){
    int p1=lower_bound(v.begin(),v.end(),a.hp)-v.begin()+1;
    int p2=lower_bound(v.begin(),v.end(),b.hp)-v.begin()+1;
    return a.atk*p1+b.atk*(p1+p2)<b.atk*p2+a.atk*(p1+p2);
}

signed main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    sc(t);
    re(i,1,10000) v.pub((1+i)*i/2);
    for(;Case<=t;++Case){
        int ans=0,sum=0;
        sc(n);
        re(i,1,n) scc(o[i].hp,o[i].atk),sum+=o[i].atk;
        sort(o+1,o+1+n,cmp);
        re(i,1,n){
            int p=lower_bound(v.begin(),v.end(),o[i].hp)-v.begin()+1;
            ans+=sum*p;
            sum-=o[i].atk;
        }
        printf("Case #%lld: %lld\n",Case,ans);
    }
    return 0;
}

D、题意比较抽象

先说第一小问，n个人上飞机，第i个人本来应该坐在第i个位置

现在第一个人票丢了，他会随机选择一个座位

从第二个人开始，如果他本来的位置上没人，他就会坐本来的位置，否则他也会随机选择一个座位

第一问是问第n个人坐到本来的位置的概率是多少

不妨假设f(x)表示x个人时候的答案

考虑只有一个人的情况：

他必定坐回一号位，概率为1.0，即f(1)=1

考虑只有两个人的情况：

如果第一个人坐了一号位，第二人必坐二号位；如果第一个人坐了二号位，那么第二人必坐一号位，概率为0.5，f(2)=0.5

接下来考虑f(3)：

如果第一个人坐了一号位，概率为1.0

如果第一个人坐了二号位，相当于第二个人变成了第一个人，概率为f(2)

如果第一个人坐了三号位，无论如何最后一个人也不会坐回原来的位置，概率为0

所以f(3)=1*1/3+f(2)*1/3+0*1/3=0.5

实际上对于任意的f(x)，f(x)=1*1/x+f(2)*1/x+...+f(x-1)*1/x+0*1/x=0.5

这意味着第一个人坐到哪个位置上了，那么答案就等于f(从那个位置开始的人数)

第二问是说上飞机顺序随机，意味着不一定第一个人没票

考虑没票的人在第几个位置上飞机，如果他在最后一个位置上飞机，概率为1，否则为0.5

剩下的人上机顺序按照全排列搞就完事了，一共有m!种方案

式子列出来大概长这样：

1*(m-1)!+0.5*(m-1)*(m-1)! / m!

化简得出答案是(m+1)/2*m

代码：

#include <bits/stdc++.h>
#define int long long
#define sc(a) scanf("%lld",&a)
#define scc(a,b) scanf("%lld %lld",&a,&b)
#define sccc(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)
#define schar(a) scanf("%c",&a)
#define pr(a) printf("%lld",a)
#define fo(i,a,b) for(int i=a;i<b;++i)
#define re(i,a,b) for(int i=a;i<=b;++i)
#define rfo(i,a,b) for(int i=a;i>b;--i)
#define rre(i,a,b) for(int i=a;i>=b;--i)
#define prn() printf("\n")
#define prs() printf(" ")
#define mkp make_pair
#define pii pair<int,int>
#define pub(a) push_back(a)
#define pob() pop_back()
#define puf(a) push_front(a)
#define pof() pop_front()
#define fst first
#define snd second
#define frt front()
#define bak back()
#define mem0(a) memset(a,0,sizeof(a))
#define memmx(a) memset(a,0x3f3f,sizeof(a))
#define memmn(a) memset(a,-0x3f3f,sizeof(a))
#define debug
#define db double
#define yyes cout<<"YES"<<endl;
#define nno cout<<"NO"<<endl;
using namespace std;
typedef vector<int> vei;
typedef vector<pii> vep;
typedef map<int,int> mpii;
typedef map<char,int> mpci;
typedef map<string,int> mpsi;
typedef deque<int> deqi;
typedef deque<char> deqc;
typedef priority_queue<int> mxpq;
typedef priority_queue<int,vector<int>,greater<int> > mnpq;
typedef priority_queue<pii> mxpqii;
typedef priority_queue<pii,vector<pii>,greater<pii> > mnpqii;
const int maxn=500005;
const int inf=0x3f3f3f3f3f3f3f3f;
const int MOD=100000007;
const db eps=1e-10;
int qpow(int a,int b){int tmp=a%MOD,ans=1;while(b){if(b&1){ans*=tmp,ans%=MOD;}tmp*=tmp,tmp%=MOD,b>>=1;}return ans;}
int lowbit(int x){return x&-x;}
int max(int a,int b){return a>b?a:b;}
int min(int a,int b){return a<b?a:b;}
int mmax(int a,int b,int c){return max(a,max(b,c));}
int mmin(int a,int b,int c){return min(a,min(b,c));}
void mod(int &a){a+=MOD;a%=MOD;}
bool chk(int now){}
int half(int l,int r){while(l<=r){int m=(l+r)/2;if(chk(m))r=m-1;else l=m+1;}return l;}
int ll(int p){return p<<1;}
int rr(int p){return p<<1|1;}
int mm(int l,int r){return (l+r)/2;}
int lg(int x){if(x==0) return 1;return (int)log2(x)+1;}
bool smleql(db a,db b){if(a<b||fabs(a-b)<=eps)return true;return false;}
db len(db a,db b,db c,db d){return sqrt((a-c)*(a-c)+(b-d)*(b-d));}
bool isp(int x){if(x==1)return false;if(x==2)return true;for(int i=2;i*i<=x;++i)if(x%i==0)return false;return true;}

int t,Case=1,n,m;

signed main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    sc(t);
    for(;Case<=t;++Case){
        db ansa,ansb;
        scc(n,m);
        if(n==1) ansa=1.0;
        else ansa=0.5;
        if(m==1) ansb=1.0;
        else ansb=(m+1.0)/(2.0*m);
        printf("Case #%d: ",Case);
        printf("%.6lf %.6lf\n",ansa,ansb);
    }
    return 0;
}

F、点有点权，边有边权，无向图，q个询问，每次询问从u到v的不经过点权大于w的点的最短路径长度（u和v的点权不考虑在内）

数据以邻接矩阵的形式给出，保证自己到自己的距离为0

首先任意两点一定是可达的，直接从起点走到终点完事，起点终点的点权都可以忽略

接下来考虑到n<200，估计floyd可以搞一搞

假设dp[k][i][j]表示在经过前k个点权最小的点的情况下，i到j的最短距离

那么先要把点权离散化一下，找到每个点对应点权的排名，ord[i]代表排名为i的点原来的编号，用pair按照第一维排序就行

对于每个询问，二分找到小于等于它的最大点权对应点的排名，输出dp[排名][x][y]即可

考虑转移方程：

dp[k][i][j]=min(dp[k-1][i][j],dp[k-1][i][mid]+dp[k-1][mid][j]);

其中mid代表排名为k的点编号，实际上也很好理解，对每个点枚举它做为中点，更新答案，只不过floyd起到了保存不同版本的最短路的作用罢了

并且dp[0][i][j]就代表原本两点间的距离

别忘了对原来的r数组排个序，否则二分的时候会出锅

代码：

#include <bits/stdc++.h>
#define int long long
#define sc(a) scanf("%lld",&a)
#define scc(a,b) scanf("%lld %lld",&a,&b)
#define sccc(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)
#define schar(a) scanf("%c",&a)
#define pr(a) printf("%lld",a)
#define fo(i,a,b) for(int i=a;i<b;++i)
#define re(i,a,b) for(int i=a;i<=b;++i)
#define rfo(i,a,b) for(int i=a;i>b;--i)
#define rre(i,a,b) for(int i=a;i>=b;--i)
#define prn() printf("\n")
#define prs() printf(" ")
#define mkp make_pair
#define pii pair<int,int>
#define pub(a) push_back(a)
#define pob() pop_back()
#define puf(a) push_front(a)
#define pof() pop_front()
#define fst first
#define snd second
#define frt front()
#define bak back()
#define mem0(a) memset(a,0,sizeof(a))
#define memmx(a) memset(a,0x3f3f,sizeof(a))
#define memmn(a) memset(a,-0x3f3f,sizeof(a))
#define debug
#define db double
#define yyes cout<<"YES"<<endl;
#define nno cout<<"NO"<<endl;
using namespace std;
typedef vector<int> vei;
typedef vector<pii> vep;
typedef map<int,int> mpii;
typedef map<char,int> mpci;
typedef map<string,int> mpsi;
typedef deque<int> deqi;
typedef deque<char> deqc;
typedef priority_queue<int> mxpq;
typedef priority_queue<int,vector<int>,greater<int> > mnpq;
typedef priority_queue<pii> mxpqii;
typedef priority_queue<pii,vector<pii>,greater<pii> > mnpqii;
const int maxn=500005;
const int inf=0x3f3f3f3f3f3f3f3f;
const int MOD=100000007;
const db eps=1e-10;
int qpow(int a,int b){int tmp=a%MOD,ans=1;while(b){if(b&1){ans*=tmp,ans%=MOD;}tmp*=tmp,tmp%=MOD,b>>=1;}return ans;}
int lowbit(int x){return x&-x;}
int max(int a,int b){return a>b?a:b;}
int min(int a,int b){return a<b?a:b;}
int mmax(int a,int b,int c){return max(a,max(b,c));}
int mmin(int a,int b,int c){return min(a,min(b,c));}
void mod(int &a){a+=MOD;a%=MOD;}
bool chk(int now){}
int half(int l,int r){while(l<=r){int m=(l+r)/2;if(chk(m))r=m-1;else l=m+1;}return l;}
int ll(int p){return p<<1;}
int rr(int p){return p<<1|1;}
int mm(int l,int r){return (l+r)/2;}
int lg(int x){if(x==0) return 1;return (int)log2(x)+1;}
bool smleql(db a,db b){if(a<b||fabs(a-b)<=eps)return true;return false;}
db len(db a,db b,db c,db d){return sqrt((a-c)*(a-c)+(b-d)*(b-d));}
bool isp(int x){if(x==1)return false;if(x==2)return true;for(int i=2;i*i<=x;++i)if(x%i==0)return false;return true;}

int t,n,q,x,y,w;
int r[205],ord[205];
int dp[205][205][205];
vector<pii> v;

void floyd(){
    re(k,1,n){
        int mid=ord[k];
        re(i,1,n){
            re(j,1,n){
                dp[k][i][j]=min(dp[k-1][i][j],
                dp[k-1][i][mid]+dp[k-1][mid][j]);
            }
        }
    }
}

signed main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    cin>>t;
    re(Case,1,t){
        cin>>n>>q;
        v.clear();
        memmx(dp);
        re(i,1,n) cin>>r[i],v.pub(mkp(r[i],i));
        re(i,1,n) re(j,1,n) cin>>dp[0][i][j];
        sort(v.begin(),v.end());
        sort(r+1,r+1+n);
        re(i,1,n) ord[i]=v[i-1].snd;
        floyd();
        cout<<"Case #"<<Case<<":\n";
        while(q--){
            cin>>x>>y>>w;
            int p=upper_bound(r+1,r+1+n,w)-r;
            p--;
            cout<<dp[p][x][y]<<endl;
        }
    }
    return 0;
}

 

标签：Provincial,Multi,const,Contest,int,typedef,queue,lld,define
来源： https://www.cnblogs.com/oneman233/p/11475234.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。