csa66

Risk Rolls

Time limit: 1000 ms
Memory limit: 256 MB

 

Alena and Boris are playing Risk today. We'll call an outcome the sum of values on the faces of 111 or more rolled dice. Alena has NNN possible outcomes whilst Boris has MMM. In turns, each one of them will choose their best possible available outcome and play it. If Alena's outcome is strictly greater than Boris's, then Alena wins; otherwise Boris wins. Whenever one of them runs out of outcomes, the game ends.

In how many turns does Alena win? What about Boris?

Standard input

The first line contains two integers NNN and MMM.

The second contains NNN integers, Alena's possible outcomes.

The third line contains MMM integers, Boris's possible outcomes.

Standard output

Print two integers AAA and BBB on the first line of the output; AAA represents the number of turns won by Alena and BBB the number of turns won by Boris.

Constraints and notes

  • 1≤N,M≤101 \leq N, M \leq 101≤N,M≤10
  • 1≤v≤241 \leq v \leq 241≤v≤24, where vvv is a possible outcome value
Input Output Explanation
1 3
24
1 2 3
1 0

In the first turn, Alena will play 242424, which will beat Boris's 333

3 1
2 1 3
24
0 1

This is the first sample with reversed outcomes for Alena and Boris.

2 2
10 1
5 5
1 1
 
4 3
3 4 5 24
9 9 9
1 2

In the first turn Alena will beat Boris because she will play 242424.

3 3
8 9 10
10 8 8
1 2

In the first turn they will play 101010 against 101010 and Boris will win. On the second turn they will play 999 versus 888 and Alena will win. The third turn is also won by Boris.

直接做就好了,排序,注意有个strictly就是大于

#include <bits/stdc++.h>
using namespace std;
int a[],b[];
int cmp(int a,int b)
{
return a>b;
}
int main()
{
int n,m;
cin>>n>>m;
int mi=min(n,m);
for(int i=;i<n;i++)
cin>>a[i];
for(int i=;i<m;i++)
cin>>b[i];
sort(a,a+n,cmp);
sort(b,b+n,cmp);
int af=,bf=;
for(int i=;i<mi;i++)
if(a[i]>b[i])af++;
else bf++;
cout<<af<<" "<<bf;
return ;
}

Processing Discounts

Time limit: 1000 ms
Memory limit: 256 MB

 

You've just placed an order of XXX USD on an online shopping website. The website has NNN special discounts: if you make a purchase of at least AiA_iA​i​​ USD, you get back BiB_iB​i​​ USD. It may be advantageous to increase your order bill just so you would be eligible of certain discount offers.

What's the minimum amount of USD that you have to pay in the end, after processing the discounts?

Standard input

The first line contains two integers, NNN and XXX.

The next NNN lines contain a pair of integers, AiA_iA​i​​ and BiB_iB​i​​.

Standard output

Print the answer on the first line.

Constraints and notes

  • 1≤N≤1051 \leq N \leq 10^51≤N≤10​5​​
  • 1≤X,Ai,Bi≤1061\leq X, A_i, B_i \leq 10^61≤X,A​i​​,B​i​​≤10​6​​
  • The online shopping website will never become in debt to you, i.e. the discount offers are chosen in such a way that you'd never reach a negative amount of payment.
Input Output Explanation
3 99
50 5
75 10
100 5
80

We're eligible for the first two discount offers, so we get 5+10=155 + 10 = 155+10=15 USD back. This means that in the end we'll pay 99−15=8499 - 15 = 8499−15=84 USD.

If we increase our order up to 100100100 USD, we'll be eligible for the third offer as well and we'll pay only 100−5−10−5=80100 - 5 - 10 - 5 = 80100−5−10−5=80 USD.

5 50
10 1
20 2
30 3
30 3
100 10
41

We're eligible for all the discount offers besides the last one. If we were to increase our payment in order to get the last offer, we would end up with 100−10−3−3−2−1=81100 - 10 - 3 - 3 - 2 - 1 = 81100−10−3−3−2−1=81 USD.

It's better to only consider the first 333, we end up spending 50−3−3−2−1=4150 - 3 - 3 - 2 - 1 = 4150−3−3−2−1=41 USD.

1 10
100 95
5
 
1 200
100 95
105
 
 
B就是一个优惠券的问题,排下序,找到付款最小值就行了
#include<bits/stdc++.h>
using namespace std;
int n,x;
const int N=1e5+;
pair<int,int> a[N];
int main()
{
scanf("%d%d",&n,&x);
for(int i=; i<n; i++)
scanf("%d%d",&a[i].first,&a[i].second);
sort(a,a+n);
int sum=x, s=;
for(int i=; i<n; i++)
s+=a[i].second,sum=min(sum,max(a[i].first,x)-s);
printf("%d\n",sum);
return ;
}

Counting Quacks

Time limit: 1000 ms
Memory limit: 256 MB

 

There are NN ducks on a lake. Every duck ii quacks periodically, once every X_iX​i​​ moments of time; i.e. it quacks for the first time at the X_i^{\text{th}}X​i​th​​ moment of time, it quacks for the second time at the {2 * X_i}^{\text{th}}2∗X​i​​​th​​ moment and so on...

Alex is sitting near this lake and he asks himself:

  • What's the maximum number of quacks i'll hear at the same moment of time?
  • How many times i'll hear this many quacks throughout my staying at the lake?

Alex isn't feeling so contemplative today, so he's leaving the lake after TT moments of time. After he leaves he won't be able to hear any more quacks.

Standard input

The first line contains two integers, NN and TT.

The next line contains NN integers representing XX.

Standard output

The first line contains two integers separated by space, as described in the statement.

Constraints and notes

  • 1 \leq N \leq 10^51≤N≤10​5​​
  • 1 \leq T \leq 10^61≤T≤10​6​​
  • 1 \leq X_i \leq 10^61≤X​i​​≤10​6​​ for each 1 \leq i \leq N1≤i≤N
  • Alex comes at the lake at the moment of time 11.
Input Output
3 6
2 2 3
3 1
3 5
2 2 3
2 2
6 10
1 2 3 4 5 6
4 1

C当时太脑残了,没想到正确的做法,甚至想着去维护这些数,但是T不大啊,直接用埃筛的思想处理下就行了,复杂度O(T+TogT)

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+;
int n,T,a[N],M[N];
int main()
{
scanf("%d%d",&n,&T);
for(int i=,x; i<n; i++)
scanf("%d",&x),++M[x];
for(int i=; i<=T; i++)
{
if(!M[i])continue;
for(int j=i; j<=T; j+=i)a[j]+=M[i];
}
int ans=,cnt=;
for(int i=; i<=T; i++)
if(a[i]>ans)ans=a[i],cnt=;
else if(a[i]==ans) cnt++;
printf("%d %d\n",ans,cnt);
return ;
}

Flipping Matrix

Time limit: 1000 ms
Memory limit: 256 MB

 

You are given a binary matrix AA of size N \times NN×N. You are allowed to perform the following two operations:

  • Take two rows and swap them. If we want to swap rows xx and yy, we'll encode this operation as R x y.
  • Take two columns and swap them. If we want to swap columns xx and yy, we'll encode this operation as C x y.

Is it possible to obtain only values of 11 on the main diagonal of AA by performing a sequence of at most NN operations? If so, print the required operations.

Standard input

The first line contains NN.

The next NN lines contain NN binary values separated by spaces, representing AA.

Standard output

If there is no solution, print -1−1.

Otherwise, print every operation on a separated line.

Constraints and notes

  • 2 \leq N \leq 10^32≤N≤10​3​​
  • 0 \leq A_{i, j} \leq 10≤A​i,j​​≤1 for every 1 \leq i, j \leq N1≤i,j≤N
Input Output
3
0 0 1
0 1 0
1 0 0
C 1 3
4
1 1 0 0
0 1 0 1
1 1 0 0
0 0 0 1
-1
5
0 1 0 0 1
0 0 1 0 0
0 1 0 0 0
0 0 1 1 0
1 0 0 0 0
R 1 5
C 2 3

是个特判题,虽说可以交换行和列,但是其实交换哪个都一样,dfs遍历看看有没有机会得到对角线全是1,需要优秀的暴力,因为n还是很大的

#include<bits/stdc++.h>
using namespace std;
const int N=;
int a[N][N],F[N],n,y[N];
int dfs(int x)
{
for(int i=; i<=n; i++)
if(a[x][i]&&!y[i])
{
y[i]=;
if(!F[i]||dfs(F[i]))
{
F[i]=x;
return ;
}
}
return ;
}
int la()
{
for(int i=; i<=n; i++)
{
memset(y,,sizeof y);
if(!dfs(i))return ;
}
return ;
}
int main()
{
scanf("%d",&n);
for(int i=; i<=n; i++)
for(int j=; j<=n; j++)
scanf("%d",a[i]+j);
if(!la())puts("-1");
else
{
for(int i=; i<=n; i++)
for(int j=; j<=n; j++)
if(F[j]==i)
{
if(j!=i)swap(F[j],F[i]),printf("C %d %d\n",i,j);
break;
}
}
return ;
}

csa Round #66 (Div. 2 only)的更多相关文章

  1. csa Round #73 (Div. 2 only)

    Three Equal Time limit: 1000 msMemory limit: 256 MB   You are given an array AA of NN integers betwe ...

  2. BestCoder Round #66 (div.2)B GTW likes gt

    思路:一个O(n)O(n)的做法.我们发现b_1,b_2,...,b_xb​1​​,b​2​​,...,b​x​​都加11就相当于b_{x+1},b_{x+2},...,b_nb​x+1​​,b​x+ ...

  3. BestCoder Round #66 (div.2)

    构造 1002 GTW likes gt 题意:中文题面 分析:照着题解做的,我们可以倒着做,记一下最大值,如果遇到了修改操作,就把最大值减1,然后判断一下这个人会不会被消灭掉,然后再更新一下最大值. ...

  4. HDU5597/BestCoder Round #66 (div.2) GTW likes function 打表欧拉函数

    GTW likes function      Memory Limit: 131072/131072 K (Java/Others) 问题描述 现在给出下列两个定义: f(x)=f_{0}(x)=\ ...

  5. HDU5596/BestCoder Round #66 (div.2) 二分BIT/贪心

    GTW likes gt    Memory Limit: 131072/131072 K (Java/Others) 问题描述 从前,有nn只萌萌的GT,他们分成了两组在一起玩游戏.他们会排列成一排 ...

  6. HDU 5596/BestCoder Round #66 (div.2) GTW likes math 签到

    GTW likes math  Memory Limit: 131072/131072 K (Java/Others) 问题描述 某一天,GTW听了数学特级教师金龙鱼的课之后,开始做数学<从自主 ...

  7. BestCoder Round #66 (div.2) hdu5592

    GTW likes math Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) ...

  8. CSA Round #53 (Div. 2 only) Histogram Partition(模拟)

    传送门 题意 给出一个数组A,你有一个数组B(一开始全为0),询问多少次操作后B转化为A 一次操作:选择一段区间,加上某个正整数 分析 构建一个栈, 输入一个数,若当前栈空或栈顶元素比输入小,则加入栈 ...

  9. CSA Round #50 (Div. 2 only) Min Swaps(模拟)

    传送门 题意 给出一个排列,定义\(value为\sum_{i=1}^{n-1}abs(f[i+1]-f[i])\) \(swap(a[i],a[j])(i≠j)为一次交换\),询问最少的交换次数使得 ...

随机推荐

  1. 登录控制 BaseController

    执行方法前 判断 sessin 登录信息 是否为空 ,空的话 返回 登录界面 并且给 LoginUser 赋值 public abstract class BaseController : Contr ...

  2. IE浏览器已经卸载,但是桌面上的图标却无法删除的解决方案

    第一步——win+R运行[regedit],打开注册表. 第二步——在注册表里面依次找到HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVer ...

  3. SAP OData编程指南

    OData(Open Data Protocol)协议是一个开放的工业标准,用于定义RESTFul API的设计和使用.我的文章标题前加上SAP的前缀,只是为了表明这篇文章介绍的是Jerry在SAP项 ...

  4. UVA 11491 Erasing and Winning 奖品的价值 (贪心)

    题意:给你一个n位整数,让你删掉d个数字,剩下的数字要尽量大. 题解:因为最后数字位数是确定的,而且低位数字对答案的贡献是一定不及高位数字的,所以优先选择选最大且最靠左边的数字,但是有一个限制,选完这 ...

  5. 八数码问题(一) 暴力BFS + STL

    八数码问题是一个经典的人工智能问题.具体问题不累述了. 思路:由于存在多组测试数据,可以考虑“打表法“.所谓打表法,即枚举所有的初始情况,记录其到达终点的路径.而在这个题目中,顺序打表会调用很多次BF ...

  6. 修改Windows默认调试器

    程序崩溃时,系统会弹窗让你选择是否进行调试,可以设置系统默认调试器. 注册表位置: HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Windows NT/CurrentVe ...

  7. IOS使用Jenkins进行持续集成

    本文主要讲述在开发过程中,提高工作效率而进行的IOS-Jenkins的持续集成. 背景 平时我们开发完成IOS项目,需要打包给测试人员进行测试.其中的过程需要重复进行:修改配置项--编译---连接设备 ...

  8. 使用powershell批量更新git仓库

    Get-ChildItem D:\GitHub\NetCore | ForEach-Object -Process{ cd $_.name; git pull; cd ../ }

  9. Oracle rownum的理解

    核心过程分三步: 从表中取出行(无索引的话,顺序取出). 根据当前结果集,为当前行添加rownum. 条件筛选,如通过则添加到结果集中. 完.

  10. W3CPLUS DEMO一些有意思的效果备份

    时间轴轮播图: http://www.w3cplus.com/w3cplusDemo/demos/timeline.html css3各种图标效果: http://www.w3cplus.com/w3 ...