【SinGuLaRiTy-1037】 Copyright (c) SinGuLaRiTy 2017. All Rights Reserved.

Chess

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Problem Description

車是中国象棋中的一种棋子，它能攻击同一行或同一列中没有其他棋子阻隔的棋子。一天，小度在棋盘上摆起了许多車……他想知道，在一共N×M个点的矩形棋盘中摆最多个数的車使其互不攻击的方案数。他经过思考，得出了答案。但他仍不满足，想增加一个条件：对于任何一个車A，如果有其他一个車B在它的上方（車B行号小于車A），那么車A必须在車B的右边（車A列号大于車B）。现在要问问你，满足要求的方案数是多少。

Input

第一行一个正整数T，表示数据组数。对于每组数据：一行，两个正整数N和M（N<=1000，M<=1000）。

Output

对于每组数据输出一行，代表方案数模1000000007（1e9+7）。

Sample Input

1
1 1

Sample Output

1

Code

基本组合数学求组合数

  1. #include<cstring>
  2. #include<cstdio>
  3. #include<cmath>
  4. #include<algorithm>
  5. #include<iostream>
  6. #include<cstdlib>
  7.  
  8. #define MAXN 1010
  9. #define LL long long
  10.  
  11. using namespace std;
  12.  
  13. int T;
  14.  
  15. LL n,m,p=;
  16.  
  17. LL quick_mod(LL a,LL b)
  18. {
  19.     LL ans=;
  20.     a%=p;
  21.     while(b)
  22.     {
  23.         if(b&)
  24.         {
  25.             ans=ans*a%p;
  26.             b--;
  27.         }
  28.         b>>=;
  29.         a=a*a%p;
  30.     }
  31.     return ans;
  32. }
  33.  
  34. LL C(LL n,LL m)
  35. {
  36.     if(m>n)
  37.         return ;
  38.     LL ans=;
  39.     for(int i=;i<=m;i++)
  40.     {
  41.         LL a=(n+i-m)%p;
  42.         LL b=i%p;
  43.         ans=ans*(a*quick_mod(b,p-)%p)%p;
  44.     }
  45.     return ans;
  46. }
  47.  
  48. LL Lucas(LL n,LL m)
  49. {
  50.     if(m==)
  51.         return ;
  52.     return C(n%p,m%p)*Lucas(n/p,m/p)%p;
  53. }
  54.  
  55. int main()
  56. {
  57.     scanf("%d",&T);
  58.     while(T--)
  59.     {
  60.         cin>>n>>m;
  61.         if(n>m)
  62.             swap(n,m);
  63.         if(n==||m==)
  64.         {
  65.             cout<<;
  66.             continue;
  67.         }
  68.         cout<<Lucas(m,n)<<endl;
  69.     }
  70.     return ;
  71. }

Factory

Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 132768/132768 K (Java/Others)

Problem Description

我们将A省简化为由N个城市组成，某些城市之间存在双向道路，而且A省的交通有一个特点就是任意两个城市之间都能通过道路相互到达，且在不重复经过城市的情况下任意两个城市之间的到达方案都是唯一的。聪明的你一定已经发现，这些城市构成了树这样一个结构。现在百度陆续开了许许多多的子公司。每家子公司又会在各城市中不断兴建属于该子公司的办公室。由于各个子公司之间经常有资源的流动，所以公司员工常常想知道，两家子公司间的最小距离。我们可以把子公司看成一个由办公室组成的集合。那么两个子公司A和B的最小距离定义为min(dist(x，y))（x∈A，y∈B）。其中dist(x，y)表示两个办公室之间的最短路径长度。现在共有Q个询问，每次询问分别在两个子公司间的最小距离。

Input

第一行一个正整数T，表示数据组数。对于每组数据：第一行两个正整数N和M。城市编号为1至N，子公司编号为1至M。接下来N-1行给定所有道路的两端城市编号和道路长度。接下来M行，依次按编号顺序给出各子公司办公室所在位置，每行第一个整数G，表示办公室数，接下来G个数为办公室所在位置。接下来一个整数Q，表示询问数。接下来Q行，每行两个正整数a,b(a不等于b），表示询问的两个子公司。【数据范围】0<=边权<=100 1<=N,M,Q,工厂总数<=100000

Output

对于每个询问，输出一行，表示答案。

Sample Input

1
3 3
1 2 1
2 3 1
2 1 1
2 2 3
2 1 3
3
1 2
2 3
1 3

Sample Output

1
0
0

Code

预处理LCA+容斥原理

  1. #include<cstdio>
  2. #include<cstring>
  3. #include<iostream>
  4. #include<algorithm>
  5. #include<vector>
  6.  
  7. #define inf 0x3f3f3f3f
  8.  
  9. using namespace std;
  10.  
  11. int fa[],anc[][],deep[],dis[];
  12. struct node
  13. {
  14.     int to;
  15.     int val;
  16. };
  17. vector<struct node > edge[];
  18.  
  19. int T,n,m;
  20.  
  21. vector<int > vec[];
  22.  
  23. void dfs(int x)
  24. {
  25.     anc[x][]=fa[x];
  26.     for(int i=;i<=;i++)
  27.     {
  28.         anc[x][i]=anc[anc[x][i-]][i-];
  29.     }
  30.     int len=edge[x].size();
  31.     for(int i=;i<len;i++)
  32.     {
  33.         struct node next=edge[x][i];
  34.         if(next.to!=fa[x])
  35.         {
  36.             fa[next.to]=x;
  37.             deep[next.to]=deep[x]+;
  38.             dis[next.to]=dis[x]+next.val;
  39.             dfs(next.to);
  40.         }
  41.     }
  42. }
  43.  
  44. int LCA(int x,int y)
  45. {
  46.     if(deep[x]<deep[y])
  47.         swap(x,y);
  48.     for(int i=;i>=;i--)
  49.     {
  50.         if(deep[y]<=deep[anc[x][i]])
  51.         {
  52.             x=anc[x][i];
  53.         }
  54.     }
  55.     if(x==y)
  56.         return x;
  57.     for(int i=;i>=;i--)
  58.     {
  59.         if(anc[x][i]!=anc[y][i])
  60.         {
  61.             x=anc[x][i];
  62.             y=anc[y][i];
  63.         }
  64.     }
  65.     return anc[x][];
  66. }
  67.  
  68. void Init()
  69. {
  70.     for(int i=;i<=n;i++)
  71.     {
  72.         edge[i].clear();
  73.         vec[i].clear();
  74.     }
  75.     memset(fa,,sizeof(fa));
  76.     memset(anc,,sizeof(anc));
  77. }
  78.  
  79. int main()
  80. {
  81.     scanf("%d",&T);
  82.     while(T--)
  83.     {
  84.         int u,v,w;
  85.         scanf("%d%d",&n,&m);
  86.         Init();
  87.         for(int i=;i<n;i++)
  88.         {
  89.             scanf("%d%d%d",&u,&v,&w);
  90.             edge[u].push_back((node){v,w});
  91.             edge[v].push_back((node){u,w});
  92.         }
  93.         for(int i=;i<=m;i++)
  94.         {
  95.             int x;
  96.             scanf("%d",&x);
  97.             for(int j=;j<=x;j++)
  98.             {
  99.                 int y;
  100.                 scanf("%d",&y);
  101.                 vec[i].push_back(y);
  102.             }
  103.         }
  104.         fa[]=;
  105.         dfs();
  106.         int q;
  107.         scanf("%d",&q);
  108.         while(q--)
  109.         {
  110.             int ans=inf;
  111.             scanf("%d%d",&u,&v);
  112.             int l1=vec[u].size();
  113.             int l2=vec[v].size();
  114.             for(int i=;i<l1;i++)
  115.             {
  116.                 for(int j=;j<l2;j++)
  117.                 {
  118.                     int lca=LCA(vec[u][i],vec[v][j]);
  119.                     ans=min(ans,dis[vec[u][i]]+dis[vec[v][j]]-dis[lca]*);
  120.                 }
  121.             }
  122.             printf("%d\n",ans);
  123.         }
  124.     }
  125.     return ;
  126. }

度度熊的交易计划

Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Problem Description

度度熊参与了喵哈哈村的商业大会，但是这次商业大会遇到了一个难题：
喵哈哈村以及周围的村庄可以看做是一共由n个片区，m条公路组成的地区。
由于生产能力的区别，第i个片区能够花费a[i]元生产1个商品，但是最多生产b[i]个。
同样的，由于每个片区的购买能力的区别，第i个片区也能够以c[i]的价格出售最多d[i]个物品。
由于这些因素，度度熊觉得只有合理的调动物品，才能获得最大的利益。
据测算，每一个商品运输1公里，将会花费1元。
那么喵哈哈村最多能够实现多少盈利呢？

Input

本题包含若干组测试数据。 每组测试数据包含： 第一行两个整数n,m表示喵哈哈村由n个片区、m条街道。 接下来n行，每行四个整数a[i],b[i],c[i],d[i]表示的第i个地区，能够以a[i]的价格生产，最多生产b[i]个，以c[i]的价格出售，最多出售d[i]个。 接下来m行，每行三个整数,u[i],v[i],k[i]，表示该条公路连接u[i],v[i]两个片区，距离为k[i]
可能存在重边，也可能存在自环。
满足: 1<=n<=500, 1<=m<=1000, 1<=a[i],b[i],c[i],d[i],k[i]<=1000, 1<=u[i],v[i]<=n

Output

输出最多能赚多少钱。

Sample Input

2 1
5 5 6 1
3 5 7 7
1 2 1

Sample Output

23

Code

最小费用最大流

  1. #include<cstring>
  2. #include<cstdio>
  3. #include<cmath>
  4. #include<algorithm>
  5. #include<cstdlib>
  6. #include<iostream>
  7. #include<queue>
  8.  
  9. #define INF 0x3f3f3f3f
  10. #define LL long long
  11.  
  12. using namespace std;
  13.  
  14. const int M=;
  15. const int N=;
  16.  
  17. struct edge
  18. {
  19.     int to;
  20.     int next;
  21.     int cap;
  22.     int cost;
  23. } e[];
  24.  
  25. int head[N],tot;
  26. int d[N], pre[N], path[N];
  27. bool vis[N];
  28.  
  29. void init()
  30. {
  31.     memset(head,-,sizeof(head));
  32.     tot=;
  33. }
  34.  
  35. void addedge(int s,int t,int cap,int cost)
  36. {
  37.     e[tot].to=t;
  38.     e[tot].cap=cap;
  39.     e[tot].cost=cost;
  40.     e[tot].next=head[s];
  41.     head[s]=tot++;
  42.     e[tot].to=s;
  43.     e[tot].cap=;
  44.     e[tot].cost=-cost;
  45.     e[tot].next=head[t];
  46.     head[t]=tot++;
  47. }
  48.  
  49. int spfa(int s,int t)
  50. {
  51.     memset(d,-INF,sizeof(d));
  52.     memset(pre,-,sizeof(pre));
  53.     memset(path,-,sizeof(path));
  54.     memset(vis,false,sizeof(vis));
  55.  
  56.     int res=d[];
  57.     d[s]=;
  58.     vis[s]=true;
  59.     queue<int>q;
  60.     q.push(s);
  61.     while (!q.empty())
  62.     {
  63.         int u=q.front();
  64.         q.pop();
  65.         vis[u]=false;
  66.         for (int i=head[u];~i;i=e[i].next)
  67.         {
  68.             int v=e[i].to;
  69.             if (d[v]<d[u]+e[i].cost&&e[i].cap>)
  70.             {
  71.                 d[v]=d[u]+e[i].cost;
  72.                 pre[v]=u;
  73.                 path[v]=i;
  74.                 if(!vis[v])
  75.                 {
  76.                     vis[v]=true;
  77.                     q.push(v);
  78.                 }
  79.             }
  80.         }
  81.     }
  82.     return d[t]!=res;
  83. }
  84.  
  85. int MinCostMaxFlow(int s,int t,int &cost)
  86. {
  87.     int flow;
  88.     flow=cost=;
  89.     while(spfa(s,t))
  90.     {
  91.         int minn=INF;
  92.         for(int i=t;i!=s&&~i;i=pre[i])
  93.             minn=min(minn,e[path[i]].cap);
  94.         for(int i=t;i!=s&&~i;i=pre[i])
  95.         {
  96.             e[path[i]].cap-=minn;
  97.             e[path[i]^].cap+=minn;
  98.         }
  99.         if(d[t]<)
  100.             break;
  101.         flow+=minn;
  102.         cost+=minn*d[t];
  103.     }
  104.     return flow;
  105. }
  106.  
  107. int main(void)
  108. {
  109.     int n,m;
  110.     while(scanf("%d%d",&n,&m)!=EOF)
  111.     {
  112.         init();
  113.         int s=,t=n+,cost;
  114.         for(int i=;i<=n;i++)
  115.         {
  116.             int a,b,c,d;
  117.             cin>>a>>b>>c>>d;
  118.             addedge(s,i,b,-a);
  119.             addedge(i,t,d,c);
  120.         }
  121.         while(m--)
  122.         {
  123.             int u,v,k;
  124.             cin>>u>>v>>k;
  125.             addedge(u,v,INF,-k);
  126.             addedge(v,u,INF,-k);
  127.         }
  128.         MinCostMaxFlow(s,t,cost);
  129.         cout<<cost<<endl;
  130.     }
  131.     return ;
  132. }

小小粉丝度度熊

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)

Problem Description

度度熊喜欢着喵哈哈村的大明星——星星小姐。为什么度度熊会喜欢星星小姐呢？首先星星小姐笑起来非常动人，其次星星小姐唱歌也非常好听。但这都不是最重要的，最重要的是，星星小姐拍的一手好代码！于是度度熊关注了星星小姐的贴吧。一开始度度熊决定每天都在星星小姐的贴吧里面签到。但是度度熊是一个非常健忘的孩子，总有那么几天，度度熊忘记签到，于是就断掉了他的连续签到。不过度度熊并不是非常悲伤，因为他有m张补签卡，每一张补签卡可以使得某一忘签到的天，变成签到的状态。那么问题来了，在使用最多m张补签卡的情况下，度度熊最多连续签到多少天呢？

Input

本题包含若干组测试数据。第一行两个整数n，m，表示有n个区间，这n个区间内的天数，度度熊都签到了；m表示m张补签卡。接下来n行，每行两个整数(l[i],r[i])，表示度度熊从第l[i]天到第r[i]天，都进行了签到操作。数据范围：1<=n<=100000 0<=m<=10000000000<=l[i]<=r[i]<=1000000000注意，区间可能存在交叉的情况。

Output

输出度度熊最多连续签到多少天。

Sample Input

2 1
1 1
3 3
1 2
1 1

Sample Output

3
3

Code

尺取法找最大区间

  1. #include<iostream>
  2. #include<cstdio>
  3. #include<algorithm>
  4. #include<cmath>
  5. #include<cstdlib>
  6. #include<cstring>
  7.  
  8. using namespace std;
  9.  
  10. typedef long long ll;
  11. const int maxn = +;
  12.  
  13. ll c[maxn];
  14.  
  15. struct node
  16. {
  17.     int type;
  18.     int pos;
  19. }arr[maxn];
  20.  
  21. struct gg
  22. {
  23.     int l,r;
  24. }qj[maxn];
  25.  
  26. bool cmp(node a,node b)
  27. {
  28.     if(a.pos==b.pos)
  29.         return a.type<b.type;
  30.     return a.pos<b.pos;
  31. }
  32.  
  33. int main()
  34. {
  35.     int n,m;
  36.     while(~scanf("%d%d",&n,&m))
  37.     {
  38.         for(int i=;i<n;i++)
  39.         {
  40.             arr[i].type=;
  41.             arr[i+n].type=;
  42.             scanf("%d%d",&arr[i].pos,&arr[i+n].pos);
  43.         }
  44.         sort(arr,arr+n*,cmp);
  45.         int len=,num=,spos;
  46.         spos=arr[].pos;
  47.         for(int i=;i<n*;i++)
  48.         {
  49.             if(arr[i].type==)
  50.             {
  51.                 if(num==)
  52.                     spos=arr[i].pos;
  53.                 num++;
  54.             }
  55.             if(arr[i].type==)
  56.                 num--;
  57.             if(num==)
  58.             {
  59.                 qj[len].l=spos,qj[len].r=arr[i].pos;
  60.                 len++;
  61.             }
  62.         }
  63.         ll ans=;
  64.         c[]=;
  65.         for(int i=;i<len;i++)
  66.         {
  67.             c[i+]=c[i]+qj[i].r-qj[i].l+;
  68.         }
  69.         for(int i=,j=;i<len;i++)
  70.         {
  71.             while(j<len&&(qj[j].r-qj[i].l+-c[j+]+c[i]<=m))
  72.             {
  73.                 ans=max(ans,(ll)(qj[j].r-qj[i].l+));
  74.                 j++;
  75.             }
  76.             ll tep=c[j]-c[i];
  77.             ans=max(ans,tep+m);
  78.         }
  79.         printf("%I64d\n",ans);
  80.     }
  81.     return ;
  82. }

Time: 2017-08-15

[SinGuLaRiTy] 2017 百度之星程序设计大赛 初赛B的更多相关文章

  1. [SinGuLaRiTy] 2017 百度之星程序设计大赛 初赛A

    [SinGuLaRiTy-1036] Copyright (c) SinGuLaRiTy 2017. All Rights Reserved. 小C的倍数问题 Time Limit: 2000/100 ...

  2. HDU 6118 度度熊的交易计划 【最小费用最大流】 （2017"百度之星"程序设计大赛 - 初赛（B））

    度度熊的交易计划 Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total S ...

  3. HDU 6119 小小粉丝度度熊 【预处理+尺取法】（2017"百度之星"程序设计大赛 - 初赛（B））

    小小粉丝度度熊 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Sub ...

  4. HDU 6114 Chess 【组合数】（2017"百度之星"程序设计大赛 - 初赛（B））

    Chess Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submi ...

  5. HDU 6109 数据分割 【并查集+set】 （2017"百度之星"程序设计大赛 - 初赛（A））

    数据分割 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submis ...

  6. HDU 6108 小C的倍数问题 【数学】 （2017"百度之星"程序设计大赛 - 初赛（A））

    小C的倍数问题 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Sub ...

  7. HDU 6122 今夕何夕 【数学公式】 （2017"百度之星"程序设计大赛 - 初赛（A））

    今夕何夕 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submis ...

  8. HDU 6113 度度熊的01世界 【DFS】（2017"百度之星"程序设计大赛 - 初赛（A））

    度度熊的01世界 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Su ...

  9. 2017"百度之星"程序设计大赛 - 初赛（A） [ hdu 6108 小C的倍数问题 ] [ hdu 6109 数据分割 ] [ hdu 6110 路径交 ] [ hdu 6112 今夕何夕 ] [ hdu 6113 度度熊的01世界 ]

    这套题体验极差. PROBLEM 1001 - 小C的倍数问题 题 OvO http://acm.hdu.edu.cn/showproblem.php?pid=6108 (2017"百度之星 ...

随机推荐

  1. vsftpd设置被动模式

    完整配置 listen=yes listen_port= max_clients= max_per_ip= local_max_rate= anonymous_enable=no local_enab ...

  2. Kali终端美化

    首先安装figlet和cowsay root@sch01ar:~# apt-get install figlet root@sch01ar:~# apt-get install cowsay 用lea ...

  3. Aptana Studio 3 如何汉化，实现简体中文版

    这篇文章写了又一年多的时间了,哈哈,今天更新一次 此处修正的下面教程的[第五步]Babel Language Pack Update Site for Helioshttp://download.ec ...

  4. 微信公众平台PHP示例一

    <?php /** * Created by PhpStorm. * User: Administrator * Date: 2015-12-18 * Time: 21:51 */ define ...

  5. Mycat之日志分析跨分片事务以及存储过程的执行过程

    1 针对成功事务: 过程说明: 1.初始化连接,路由到各个分片 2.开启非阻塞执行更新,然后执行时候每个节点执行2次 3.执行提交,各节点返回commit 4.释放连接,先释放datasource然后 ...

  6. canvas二进制字符下落

      ?   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 3 ...

  7. Subscript & Inheritance

    [Subscript] 1.subscript的定义: 2.Subscript的使用: 3.可以定义多维subscript: 多维Subscript的使用: [Inheritance] 1.overr ...

  8. 无锁的同步策略——CAS操作详解

    目录 1. 从乐观锁和悲观锁谈起 2. CAS详解 2.1 CAS指令 2.3 Java中的CAS指令 2.4 CAS结合失败重试机制进行并发控制 3. CAS操作的优势和劣势 3.1 CAS相比独占 ...

  9. 算法技巧讲解》关于对于递推形DP的前缀和优化

    这是在2016在长沙集训的第三天,一位学长讲解了“前缀和优化”这一技巧,并且他这一方法用的很6,个人觉得很有学习的必要. 这一技巧能使线性递推形DP的速度有着飞跃性的提升,从O(N2)优化到O(N)也 ...

  10. 面试题:SSH项目总结 !=!=未看 没用

    阿玻罗软件(上海)有限公司已经两年了.中国银行营销系统,到民生银行小微信贷工厂建设.再到交通银行ioffice移动平台项目.以前所学的SSH好多都用不上 公司的框架.都是负责项目的贷款查找模块开发和测 ...