ACM-ICPC 2018 沈阳赛区网络预赛 D A*算法 F 有上下界的网络流 G分解质因数+公式 容斥 I 模拟 K讨论

最新推荐文章于 2019-03-18 00:24:10 发布
最新推荐文章于 2019-03-18 00:24:10 发布
阅读量493 收藏
点赞数
分类专栏： 素数 数论 最短路 数学-公式 搜索 网络流-最大流
本文为博主原创文章，未经博主允许也可以转载。
本文链接：https://blog.csdn.net/FrankAx/article/details/82555817
版权
数论 同时被 3 个专栏收录
45 篇文章 0 订阅
订阅专栏
数学-公式
43 篇文章 1 订阅
订阅专栏
最短路
26 篇文章 0 订阅
订阅专栏

D
题意：找是否存在第k短路且判断长度是否小于等于T。
思路：A*算法裸题。

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
const int AX = 1e5+66;
const int MAXN = 1e4+66;
int n , m , k;
int s ,t ;
int tot ;
int retot ;
struct edge{
    int to , w ;
    int next1;
}G[AX] , RG[AX];
//f = g + h 
struct Node{
    int v;
    int f , h , g;
    bool operator < ( const Node &a ) const{
        if( f == a.f ){
            return g > a.g;
        }
        return f > a.f;
    }
};

int dis[MAXN];
int head[MAXN];
int rehead[AX];
int vis[MAXN];
void addedge( int u , int v , int c ){
    G[tot].to = v;
    G[tot].w = c;
    G[tot].next1 = head[u];
    head[u] = tot++;

    RG[retot].to = u;
    RG[retot].w = c;
    RG[retot].next1 = rehead[v];
    rehead[v] = retot ++;
}
void SPFA(){
    for( int i = 1 ; i <= n ; i++ ){
        dis[i] = INF;
    }   
    dis[t] = 0;
    queue<int>Q;
    Q.push(t);
    while( !Q.empty() ){
        int u = Q.front();
        Q.pop();
        for( int i = rehead[u] ; ~i ; i = RG[i].next1 ){
            int v = RG[i].to ;
            int w = RG[i].w ;
            if( dis[v] > dis[u] + w ){
                dis[v] = dis[u] + w;
                Q.push(v);
            }
        }
    }   
}

int Astar( Node a ){
    memset( vis , 0 ,sizeof(vis) );
    if( dis[s] == INF ) return -1;
    if( s == t ) k++;
    priority_queue<Node>Q;
    Q.push(a);
    while( !Q.empty() ){
        Node tmp = Q.top();
        Q.pop();
        int v = tmp.v;
        vis[v] ++ ;
        if( vis[t] == k ) return tmp.g;
        for( int i = head[v] ; ~i ; i = G[i].next1 ){
            Node p;
            p.v = G[i].to;
            p.h = dis[G[i].to];
            p.g = tmp.g + G[i].w;
            p.f = p.g + p.h;
            Q.push(p);
        }
    }
    return -1;
}

int main(){
    int T;
    while( ~scanf("%d%d",&n,&m) ){
        scanf("%d%d%d%d",&s,&t,&k,&T);
        tot = 0 ;
        retot = 0;
        memset( head , -1 , sizeof(head) );
        memset( rehead , -1 , sizeof(rehead) );
        int x , y , w ;
        for( int i = 0 ; i < m ; i++ ){
            scanf("%d%d%d",&x,&y,&w);
            addedge( x , y , w );
        }
        SPFA();
        Node a;
        a.v = s ;
        a.g = 0;
        a.h = dis[s];
        a.f = a.g + a.h;
        int g = Astar(a);
    //printf("%d\n",g);
        if( g != -1 && g <= T ){
            printf("yareyaredawa\n");
        }else{
            printf("Whitesnake!\n");
        }
    } 
    return 0 ;
}

F
思路：有源汇有上下界的网络流。限制是ss到每个点流量为[L,R]，每个点到tt为[L,R]。
Code：

#include <bits/stdc++.h>
#define LL long long 
#define INF 0x3f3f3f3f
using namespace std;
const int AX = 1e5+66;

int n , m ;
int sp , tp ;
int ss, tt ; 
int head[AX];
int d[AX];
int cur[AX];
int tot;

struct Node{
    int u , v , flow , next1 ; 
    Node( int u = 0 , int v = 0 , int flow = 0 , int next1 = 0 ):u(u),v(v),flow(flow),next1(next1){}
}G[20*AX];

void addedge(int u,int v,int flow){
    G[tot] = Node( u , v , flow , head[u] ) ; head[u] = tot++ ;
    G[tot] = Node( v , u , 0 , head[v] ) ; head[v] = tot++ ;
}

bool bfs( ){
    memset( d, -1 , sizeof(d) );
    d[sp] = 0 ;
    queue<int>q ;
    q.push( sp ) ;
    while( !q.empty() ){
        int u = q.front() ; 
        q.pop();
        for( int i = head[u] ; ~i ; i = G[i].next1 ){
            int v = G[i].v ; 
            if( d[v] == -1 && G[i].flow ) {
                d[v] = d[u] + 1 ;
                q.push(v) ;
                if( v == tp ) return true ; 
            }
        }
    } 
    return ~d[tp];
}

int dfs( int u , int cap ){
    if( u == tp ) return cap ; 
    int r = 0 ;
    for( int i = cur[u] ; ~i ; i = G[i].next1) {
        int v = G[i].v ; 
        if( G[i].flow && d[v] == d[u] + 1 ){
            int tmp = min( G[i].flow , cap - r );
            cur[u] = i ;
            tmp = dfs(v,tmp);
            r += tmp ; 
            G[i].flow -= tmp ;
            G[i^1].flow += tmp ; 
            if( r == cap ) break;
        }
    }
    if( !r ) d[u] -= 2 ;
    return r ; 
}

int Dinic( ){
    int cnt = 0 ;
    int t ;
    while( bfs() ){
        memcpy(cur,head,sizeof(head));
        while( t = dfs( sp, INF ) ) cnt += t ; 
    }
    return cnt ; 
}

int main(){
    int k , L , R ;
    int Case = 0 ;
    while( ~scanf("%d%d%d",&n,&m,&k) ){
        tot = 0 ;
        memset( head , -1 , sizeof(head) );
        sp = n + m + 1 ;  tp = n + m + 2 ; 
        ss = n + m + 3 ;  tt = n + m + 4 ;
        scanf("%d%d",&L,&R);
        int u , v ; 
        for( int i = 0 ; i < k ; i++ ){
            scanf("%d%d",&u,&v);
            addedge( u , v + n , 1 );
        }
        for( int i = 1 ; i <= n ; i++ ){
            addedge( ss , i , R - L ) ;
            addedge( sp , i , L ) ;
            addedge( ss , tp , L ) ;
        }
        for( int i = 1;  i <= m ; i++ ){
            addedge( i + n , tt , R - L ) ;
            addedge( sp , tt , L ) ;
            addedge( i + n , tp , L ) ;
        }
        addedge( tt , ss , INF ) ;
        printf("Case %d: ",++Case);
        if( Dinic() == ( n + m ) * L ) puts("Yes");
        else puts("No");
    }
    return 0 ; 
}

G
题意：an = n * n+n，求
这里写图片描述
思路：可以转化成
这里写图片描述
套容斥可以求得结果。
另：这里写图片描述
Code：

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define LL long long 
using namespace std;
const LL MOD = 1e9 + 7 ;
const int AX = 1e5 + 666 ;
const LL inv2 = 500000004;
const LL inv6 = 166666668;
LL m , n ;

LL cal( LL n , LL x ){
    LL num = n / x ; 
    return ( num * ( num + 1 ) %MOD * ( 2 * num + 1 )%MOD * inv6%MOD * x %MOD* x % MOD + num * ( num + 1 )%MOD * inv2 %MOD * x%MOD )%MOD ;
}
int fac[AX];
int tot ;

void getFac( ){
    tot = 0 ;
    for( int i = 2 ; i * i <= m ; i++ ){
        if( ( m % i ) == 0 ){
            fac[tot++] = i ; 
            while( m % i == 0 ) m /= i ;
        }
    }
    if( m > 1 ) fac[tot++] = m ;
}

int main(){
    while( ~scanf("%d%d",&n,&m) ){
        getFac();
        LL ans = cal( n , 1 ) ;
        LL res = 0LL ;
        for( int i = 1 ; i < ( 1 << tot ) ; i++ ){
            int f = 0 ; 
            LL tmp = 1LL ;
            int num = 0 ;
            for( int j = 0 ; j < tot ; j++ ){
                if( ( 1 << j ) & i ){
                    tmp = tmp * fac[j] % MOD ;
                    num ++ ;
                }
            }
            tmp = cal( n , tmp );
            if( num % 2 ){
                res = ( res + tmp % MOD ) % MOD;
            }else{
                res = ( res + MOD - tmp ) % MOD ;
            }
        }
        printf("%lld\n",(ans+MOD-res)%MOD);
    }
    return 0 ;
}

I
思路：模拟，16进制转2进制，然后奇偶校验，然后根据映射得出结果。
Code：

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define LL long long 
using namespace std;
map<char,string> mp; 
map<string , int > mp1; 
void init(){
    mp['0'] ="0000"; mp['1']="0001";mp['2']="0010";mp['3']="0011";mp['4']="0100";mp['5']="0101";mp['6']="0110";mp['7']="0111";mp['8']="1000";mp['9']="1001";mp['A']="1010";mp['B']="1011";mp['C']="1100";mp['D']="1101";mp['E']="1110";mp['F']="1111";
    mp['a']="1010";mp['b']="1011";mp['c']="1100";mp['d']="1101";mp['e']="1110";mp['f']="1111";
}
int main(){
    int T;
    init();
    ios_base::sync_with_stdio(false);
    cin.tie(0) ; cout.tie(0) ; 
    cin >> T;
    int m , n ; 
    while( T-- ){
        string a; 
        string b; 
        string c; 
        cin >> m >> n ; 
        mp1.clear();
        int asc ;
        string s ;  
        for( int i = 0 ; i < n ; i++ ){
            cin >> asc >> s ; 
            mp1[s] = asc ; 
        }
        b = "";
        cin >> a ; 
        int len = a.size();
        for( int i = 0 ; i < len ; i++ ){
            b += mp[a[i]];
        }
        len = b.size();
        for( int i = 0 ; i + 8 < len ; i += 9 ){
            int num = 0 ; 
            string tmp = "" ;
            int j ; 
            for( j = i ; j < i + 8 ; j++ ){
                if( b[j] == '1' ){
                    num ++ ; 
                }
                tmp += b[j] ; 
            }
            if( num % 2 ){
                if( b[j] == '0' ) c += tmp ; 
            }else{
                if( b[j] == '1' ) c += tmp ; 
            }
        }
        int size = c.size() ; 
        string tmp = "" ; 
        string res = "" ;
        int length = 0 ;
        for( int i = 0 ; i < size ; i ++ ){
            tmp += c[i] ; 
            if( length == m ) break ; 
            if( mp1[tmp] ){
                //cout << (char)mp1[tmp];
                res += (char)mp1[tmp];
                length ++ ;
                tmp = "";
            }
        }
        cout << res << endl;
    }   
    return 0 ;
}

K
题意：一个数为素数且任意子串为素数
思路：考虑到答案中任意一位都必须是1或质数，可知答案只可能由1、2、3、5、7构成。由于任意两个不为1的数字构成 的两位数一定可以被11整除，所以答案中除1外的数字只能出现一次；1最多出现2次，因为111可以被3整除；而 2、5、7三者一定不会有两者同时出现。因此满足条件的整数不会超过四位，全部预处理出来即可。
Code:

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

int a[21]={1,2,3,5,7,11,13,17,23,31,37,53,71,73,113,131,137,173,311,317,10000};

int init(string s){
    int cnt = 0;
    for(int i=0;i<s.length();i++){
        cnt = cnt*10 + s[i]-'0';
    }
    return cnt;
}
int t;
int main(){
    cin>>t;
    for(int i=1;i<=t;i++){
        string s;
        cin>>s;
        cout<<"Case #"<<i<<": ";
        if(s.length()>=4){
            cout<<"317"<<endl;
        }else{
            int ans = init(s);
            for(int i=0;i<21;i++){
                if(a[i]>ans){
                    cout<<a[i-1]<<endl;
                    break;
                }
            }
        }
    }
    return 0;
}
Dave_L
关注
专栏目录
ACM-ICPC 2018 沈阳赛区网络预赛 D. Made In Heaven （K短路算法模板）
大梦小半
09-08 474
题意 ： 求第k短路的权值是否超过T（权值） 解法： 网上随便找的一个求K短路的算法模板套弄一下即可 （模板要好，不然邻接表存图会TLE ， 网上换了两个模板才AC的） AC代码： #include&lt;iostream&gt; #include&lt;algorithm&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; #i...
ACM-ICPC/CCPC/JSCPC板子总结（不断更新ing）
bogedaye的博客
11-12 2897
ACM-ICPC/CCPC/JSCPC板子 Team: Three alchemists（三个炼金师） @zhoubo,18CS,Suzhou University of Science and Technology @huangyangbang,20ICS,Suzhou University of Science and Technology @shiweichun,20CS,Suzhou University of Science and Technology 一、数论 1.试除法判定质数 bool
ACM-ICPC 2018 沈阳赛区网络预赛 I（模拟）
weixin_30693183的博客
09-08 116
传送门 题面： LATTICE is learning Digital Electronic Technology. He is talented, so he understood all those pieces of knowledge in10^{-9}10−9second. In the next10^{-9}10−9second, he built...
ACM-ICPC 2018 沈阳赛区网络预赛D（k短路）
Chen.Jr的博客
09-08 267
传送门 题面： One day in the jail, F·F invites Jolyne Kujo (JOJO in brief) to play tennis with her. However, Pucci the father somehow knows it and wants to stop her. There are NN spots in the jail and MM ...
ACM-ICPC 2018 沈阳赛区网络预赛-K：Supreme Number
weixin_33835690的博客
09-08 116
Supreme Number A prime number (or a prime) is a natural number greater than11that cannot be formed by multiplying two smaller natural numbers. Now lets define a numberNas thesu...
ACM-ICPC 2018 沈阳赛区网络预赛-D：Made In Heaven（K短路+A*模板）
执念
09-08 960
Made In Heaven One day in the jail, F·F invites Jolyne Kujo (JOJO in brief) to play tennis with her. However, Pucci the father somehow knows it and wants to stop her. There are N spots in the jail an...
ACM-ICPC 历年竞赛 真题，各大赛区真题详解
04-24
**ACM-ICPC（国际大学生程序设计竞赛）概述** ACM-International Collegiate Programming Contest（简称ACM-ICPC）是由美国计算机协会（Association for Computing Machinery）主办的一项全球性的编程竞赛，旨在...
ACM-ICPC 历年竞赛 真题
10-17
ACM-ICPC 历年竞赛 真题，各大赛区真题详解，内含几大赛区各年度的真题
世界大学生程序设计竞赛(ACM-ICPC)高级教程(第一册)-程序设计中常用的计算思维方式.pdf
03-18
### 世界大学生程序设计竞赛(ACM-ICPC)高级教程(第一册)-程序设计中常用的计算思维方式 #### 一、导言 《世界大学生程序设计竞赛(ACM-ICPC)高级教程(第一册)-程序设计中常用的计算思维方式》是一部专为参加ACM-...
历年ACM-ICPC比赛
wangtao的博客
03-18 2709
历年icpc:http://codeforces.com/gyms?filterContestType=Official+ACM-ICPC+Contest&order=ID_DESC CCPC2018-湖南全国邀请赛-重现赛（感谢湘潭大学） 2018中国大学生程序设计竞赛 - 网络选拔赛 ACM/ICPC 2018亚洲区预选赛北京赛站网络赛 ACM-ICPC国际大学生程序设计竞赛北...
ACM-ICPC 2018 沈阳赛区网络预赛 D. Made In Heaven（A*，K短路）
yz467796454的博客
09-08 278
题目链接：https://nanti.jisuanke.com/t/31445   样例输入 2 2 1 2 2 14 1 2 5 2 1 4 样例输出 yareyaredawa 题意：单向图，问K短路是否小于等于T 思路：模板题，你只需要一个优秀的板子，我的板子不够优秀就T了，队友的板子够优秀，但是他居然Whitesnake！里的W没有大写wa了7发！！！！！！！！ #...
ACM-ICPC 2018 沈阳赛区网络预赛 D. Made In Heaven(K短路+启发式A*)
Eternally831143的博客
09-08 400
Made In Heaven 问题分析 题意：求111到nnn的第kkk短的路径长度，如果超过TTT输出Whitesnake!Whitesnake!Whitesnake!，否则输出yareyaredawayareyaredawayareyaredawa。 题解：这道题呢，核心就在于对于A∗A∗A*算法的理解与应用。 这里不打算长述什么是A∗A∗A*算法。 只需要知道A∗A∗A*也是基...
ACM-ICPC 2018 沈阳赛区网络预赛 G.Spare Tire (容斥)
ftx456789的博客
09-08 952
A sequence of integer{an}{an}\left \{ a_{n} \right \}can be expressed as: an=⎧⎩⎨⎪⎪⎪⎪023an−1−an−22+n+1n=0n=1n&gt;1an={0n=02n=13an−1−an−22+n+1n&gt;1 a_{n}=\left\{\begin{matrix} 0&n=0 \\ 2&n=1 \\ \...
ACM-ICPC 2018 沈阳赛区网络预赛
jkchen's Haven
09-09 358
今天真的是要自闭了。。。K短路百度第一篇模板不能用，结果一直脑残一样在那边改，其实只要拉另外一个就直接过了，哎！模拟题那题队友直接map还TLE了，哎！为什么我要一直死磕G题，哎！要是我。。。哎！还是太菜了，比赛的时候容易慌，一慌就没法静下来好好想题目了。而且比赛现场好吵，我又很容易被影响，哎！ 打完比赛有种自己一无是处的感觉。。。 K. Supreme Number 打表知道1000...
ACM-ICPC 2018 沈阳赛区网络预赛 [菜菜的我！！！]
howell
09-13 438
 A. Gudako and Ritsuka [博弈动态规划]                                                                                                       题库链接          通过率: 1.55%          通过人数: 2  留坑  B. Call of Ac...
ACM-ICPC 2018 沈阳赛区网络预赛 J Ka Chang 分块
sb的博客
09-08 351
https://nanti.jisuanke.com/t/31451 对每层的个数分块 当这个深度的节点个数&amp;gt;block时 暴力维护每个点的子树有多少个这个深度的节点 这样的层数最多有n/block个 预处理复杂度O(n*n/block) 修改直接修改这个层数总共加了多少 当深度的节点个数&amp;lt;=block时 暴力修改这个深度的每个节点 用一个bit或者线段树维护树的d...
ACM-ICPC 2018 沈阳赛区网络预赛 J Ka Chang（树分块）
untilyouydc
09-09 350
思路 因为不同深度的节点数量不同，数量少的节点，可以考虑直接进行单点更新，对于数量多的节点，可以直接记录这一层增加的值，查询的时候，看每一层有多少个节点，最后乘上增加的值就行了。 具体实现 先设定一个belong[maxn]数组，用于放同一层的节点的dfs序（这样做是为了可以在树状数组上进行单点更新，同一层的dfs序虽然不是连续的，但是也符合从小到大的顺序）。其次设定一个值block=1&l...
吉林大学ACM-ICPC代码库：图论与网络流算法集锦
"这是一份ACM/ICPC竞赛相关的代码库，来自吉林大学2005级2007-2008年度，包含了丰富的算法和数据结构实现，适用于ACM竞赛进阶学习。" 这篇资源主要涵盖的是ACM国际大学生程序设计竞赛（ACM International ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值