URAL

URAL 2035 

输入x，y，c，  找到任意一对a,b 使得a+b==c&& 0<=a<=x && 0<=b<=y

注意后两个条件，顺序搞错wa几次

#include<cstdio>
#include<algorithm>
using namespace std;
int main(){
    int x,y,c;
    while(~scanf("%d%d%d",&x,&y,&c)){
        if(x+y<c){
            puts("Impossible");
            continue;
        }
        int a,b;
        bool s=false;
        if(x>y){
            s=true;
            swap(x,y);
        }
        if(x>=c){
            a=c;
            b=0;
        }
        else{
            a=x;
            b=c-x;
        }
        if(s) swap(a,b);
        printf("%d %d\n",a,b);
    }
    return 0;
}

 

URAL 2034

无向图，边权都是1,人从s到f，走最短路，最短路可能有多条。强盗在r，强盗要抢劫的距离是从r到人走的路径的最近距离。因为可能有多条最短路，所以要求强盗到达每条最短路到最近距离，输出其中最大的。

做法 预处理出s到每个点到距离，r到每个点到距离。然后从s开始bfs，step记录的是步数，val记录的是这条路径上距离r的最近距离。

#include<cstdio>
#include<cstring>
#include<queue>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int M=1e5+10;
struct G {
    struct E {
        int v,next;
    } e[M<<1];
    int le,head[M];
    void init() {
        le=0;
        mt(head,-1);
    }
    void add(int u,int v) {
        e[le].v=v;
        e[le].next=head[u];
        head[u]=le++;
    }
} g;
bool vis[M];
void bfs(int s,int d[]) {
    mt(vis,0);
    vis[s]=true;
    queue<int> q;
    while(!q.empty()) q.pop();
    q.push(s);
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        for(int i=g.head[u]; ~i; i=g.e[i].next) {
            int v=g.e[i].v;
            if(!vis[v]) {
                vis[v]=true;
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
}
int sd[M],rd[M],d[M],ans;
struct Q {
    int step,val,id;
} now,pre;
queue<Q> q;
void solve(int s,int f) {
    ans=0;
    mt(d,0);
    now.step=0;
    now.id=s;
    now.val=rd[s];
    while(!q.empty()) q.pop();
    q.push(now);
    while(!q.empty()) {
        pre=q.front();
        q.pop();
        if(pre.id==f) {
            ans=max(ans,pre.val);
            continue;
        }
        int u=pre.id;
        for(int i=g.head[u]; ~i; i=g.e[i].next) {
            int v=g.e[i].v;
            now.val=min(pre.val,rd[v]);
            now.step=pre.step+1;
            if(now.step==sd[v]&&d[v]<now.val) {
                d[v]=now.val;
                now.id=v;
                q.push(now);
            }
        }
    }
}
int main() {
    int n,m,u,v,s,f,r;
    while(~scanf("%d%d",&n,&m)) {
        g.init();
        while(m--) {
            scanf("%d%d",&u,&v);
            g.add(u,v);
            g.add(v,u);
        }
        scanf("%d%d%d",&s,&f,&r);
        bfs(s,sd);
        bfs(r,rd);
        solve(s,f);
        printf("%d\n",ans);
    }
    return 0;
}

 vector存图会慢一些

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int M=1e5+10;
vector<int> g[M];
bool vis[M];
void bfs(int s,int d[]) {
    mt(vis,0);
    vis[s]=true;
    queue<int> q;
    while(!q.empty()) q.pop();
    q.push(s);
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        int len=g[u].size();
        for(int i=0; i<len; i++) {
            int v=g[u][i];
            if(!vis[v]) {
                vis[v]=true;
                d[v]=d[u]+1;
                q.push(v);
            }
        }
    }
}
int sd[M],rd[M],d[M],ans;
struct Q {
    int step,val,id;
} now,pre;
queue<Q> q;
void solve(int s,int f) {
    ans=0;
    mt(d,0);
    now.step=0;
    now.id=s;
    now.val=rd[s];
    while(!q.empty()) q.pop();
    q.push(now);
    while(!q.empty()) {
        pre=q.front();
        q.pop();
        if(pre.id==f) {
            ans=max(ans,pre.val);
            continue;
        }
        int u=pre.id;
        int len=g[u].size();
        for(int i=0; i<len; i++) {
            int v=g[u][i];
            now.val=min(pre.val,rd[v]);
            now.step=pre.step+1;
            if(now.step==sd[v]&&d[v]<now.val) {
                d[v]=now.val;
                now.id=v;
                q.push(now);
            }
        }
    }
}
int main() {
    int n,m,u,v,s,f,r;
    while(~scanf("%d%d",&n,&m)) {
        for(int i=1;i<=n;i++) g[i].clear();
        while(m--) {
            scanf("%d%d",&u,&v);
            g[u].push_back(v);
            g[v].push_back(u);
        }
        scanf("%d%d%d",&s,&f,&r);
        bfs(s,sd);
        bfs(r,rd);
        solve(s,f);
        printf("%d\n",ans);
    }
    return 0;
}

 

URAL 2033

手机排名按照出现次数，次数相同按照最低价格

#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
string a,b;
map<string,int> num,val;
map<string,int>::iterator it;
struct G{
    string a;
    int num,val;
    friend bool operator <(const G &a,const G &b){
        return a.num>b.num||(a.num==b.num&&a.val<b.val);
    }
}now;
vector<G> g;
int cost;
int main(){
    num.clear();
    val.clear();
    for(int i=0;i<6;i++){
        cin>>a>>b>>cost;
        num[b]++;
        if(val[b]){
            val[b]=min(val[b],cost);
        }
        else{
            val[b]=cost;
        }
    }
    g.clear();
    for(it=num.begin();it!=num.end();it++){
        now.a=it->first;
        now.num=it->second;
        now.val=val[now.a];
        g.push_back(now);
    }
    sort(g.begin(),g.end());
    cout<<g[0].a<<endl;
    return 0;
}

 

 URAL 2031

最多4个连续的能满足的 88 89 90 91

#include<cstdio>
int main(){
    int n,ans[]={16,06,68,88};
    while(~scanf("%d",&n)){
        if(n<5){
            for(int i=0;i<n;i++){
                printf("%02d ",ans[i]);
            }
        }
        else{
            printf("Glupenky Pierre");
        }
        puts("");
    }
    return 0;
}

 

 URAL 2029

汗诺塔，一开始都在A ，要移动成输入的状态，需要几步，每次都是考虑最下面的一个，然后相当于把n-1个移开，然后把第n个移动到目标处，移动n个需要2^n-1,把最后一个放到目标需要1

#include<cstdio>
typedef long long LL;
const int M=55;
char a[M];
LL p[M];
int main(){
    p[0]=1;
    for(int i=1;i<M;i++){
        p[i]=p[i-1]*2;
    }
    int n;
    while(~scanf("%d%s",&n,a)){
        LL ans=0;
        int id=0;
        for(int i=n;i>=1;i--){
            int his=a[i-1]-'A';
            if(his==id) continue;
            ans+=p[i-1];
            id=0^1^2^id^his;
        }
        printf("%lld\n",ans);
    }
    return 0;
}

 

 

 URAL 2025

n人分k队，不同队之间的人要打一场比赛，问最多能打几场，把人平均分k份打得最多

#include<cstdio>
int main(){
    int t,n,k,ans;
    while(~scanf("%d",&t)){
        while(t--){
            scanf("%d%d",&n,&k);
            int x=n/k;
            int y=n%k;
            ans=y*(x+1)*(n-x-1)+(k-y)*x*(n-x);
            printf("%d\n",ans/2);
        }
    }
    return 0;
}

 

 URAL 2024

最多存在k种不同字母，问最多几个，有几种方法达到最多

最多几个就是把前k种加起来

方法数就是有几种个数和第k种一样，那么从中选几种

#include<cstdio>
#include<cstring>
#include<algorithm>
#define mt(a,b) memset(a,b,sizeof(a))
using namespace std;
const int M=1e5+10;
char a[M];
int num[32];
int C[32][32];
int main(){
    for(int i=0;i<32;i++){
        C[i][i]=1;
        C[i][0]=1;
    }
    for(int i=1;i<32;i++){
        for(int j=1;j<i;j++){
            C[i][j]=C[i-1][j]+C[i-1][j-1];
        }
    }
    int k;
    while(~scanf("%s%d",a,&k)){
        mt(num,0);
        for(int i=0;a[i];i++){
            num[a[i]-'a']++;
        }
        sort(num,num+26);
        int sum=0;
        int kk=0;
        for(int i=25;i>=0;i--){
            sum+=num[i];
            kk++;
            if(kk==k) break;
        }
        printf("%d ",sum);
        if(k==26){
            puts("1");
            continue;
        }
        if(num[26-k]==0){
            puts("1");
            continue;
        }
        if(num[26-k-1]!=num[26-k]){
            puts("1");
            continue;
        }
        int cn=0,cm=0;
        for(int i=0;i<26;i++){
            if(num[i]==num[26-k]){
                cn++;
            }
        }
        for(int i=26-k;i<26;i++){
            if(num[i]==num[26-k]){
                cm++;
            }
        }
        printf("%d\n",C[cn][cm]);
    }
    return 0;
}

 

 

 

end