ABC189 A~D
A - Slot
题目大意
给定三个大写英文字母 C 1 , C 2 , C 3 C_1,C_2,C_3 C1,C2,C3，判断它们是否相同。
输入格式
C 1 C 2 C 3 C_1C_2C_3 C1C2C3
输出格式
如果
C
1
,
C
2
,
C
3
C_1,C_2,C_3
C1,C2,C3相等，输出Won；否则，输出Lost。
样例
| 输入 | 输出 |
|---|---|
| SSS | Won |
| WVW | Lost |
分析
这题如果不会做，就等于没学过C++吧……
代码
注意：请不要将Won和Lost写成Yes和No！
#include <cstdio>
using namespace std;
int main(int argc, char** argv)
{
char a = getchar(), b = getchar(), c = getchar();
puts((a == b && b == c)? "Won": "Lost");
return 0;
}
B - Alcoholic
题目大意
一个人要按顺序喝
N
N
N杯酒。第
i
i
i杯酒有
V
i
V_i
Vi毫升，酒精含量为
P
i
%
P_i\%
Pi%（
1
≤
i
≤
N
1\le i\le N
1≤i≤N）。
他喝的酒精总含量超过
X
X
X毫升时将会醉酒。（如果正好喝了
X
X
X毫升也不会喝醉）
他喝完第几杯酒后会第一次喝醉？
1
≤
N
≤
1
0
3
1\le N\le 10^3
1≤N≤103
0
≤
X
≤
1
0
6
0\le X\le 10^6
0≤X≤106
1
≤
V
i
≤
1
0
3
1\le V_i\le 10^3
1≤Vi≤103
0
≤
P
i
≤
100
0\le P_i\le 100
0≤Pi≤100
输入格式
N
X
N~X
N X
V
1
P
1
V_1~P_1
V1 P1
⋮
\vdots
⋮
V
N
P
N
V_N~P_N
VN PN
输出格式
如果这个人在喝完第
i
i
i杯酒后第一次喝醉，输出
i
i
i。如果他直到最后都没有喝醉，输出-1。
样例
样例输入1
2 15
200 5
350 3
样例输出1
2
第
1
1
1杯酒含有
200
×
5
%
=
10
200\times5\%=10
200×5%=10毫升的酒精。
第
2
2
2杯酒含有
350
×
3
%
=
10.5
350\times3\%=10.5
350×3%=10.5毫升的酒精。
他喝完第二杯酒后一共喝了
20.5
20.5
20.5毫升的酒精，高于最大可承受量（
15
15
15），所以我们输出
2
2
2。
样例输入2
2 10
200 5
350 3
样例输出2
2
当他正好喝了 X X X毫升的酒精时，他还没有喝醉。
样例输入3
3 1000000
1000 100
1000 100
1000 100
样例输出3
-1
他似乎免疫酒精了……
分析
第
i
i
i杯酒中酒精的量是
V
i
×
P
i
%
V_i\times P_i\%
Vi×Pi%，即
V
i
×
P
i
/
100
V_i\times P_i/100
Vi×Pi/100。
这时，我们将题目转化一下，就是求符合
V
1
×
P
1
/
100
+
V
2
×
P
2
/
100
+
.
.
.
+
V
i
×
P
i
/
100
>
X
V_1\times P_1/100+V_2\times P_2/100+...+V_i\times P_i/100 > X
V1×P1/100+V2×P2/100+...+Vi×Pi/100>X的最小
i
i
i。所以，我们很容易想到在输入的同时计算
V
1
×
P
1
/
100
+
V
2
×
P
2
/
100
+
.
.
.
+
V
i
×
P
i
/
100
V_1\times P_1/100+V_2\times P_2/100+...+V_i\times P_i/100
V1×P1/100+V2×P2/100+...+Vi×Pi/100，当它大于
X
X
X时输出
i
i
i。
但是，这里有一个问题。
由于C++存在浮点数精度误差，所以这样算可能会得到错误的结果。
例如，下面一组数据：（数据来自AtCoder官方题解）
3 13
30 13
35 13
35 13
在很多环境下，程序会输出3，而这组数据的正确答案是-1。所以，我们考虑把前面的式子转化一下。
V
1
×
P
1
/
100
+
V
2
×
P
2
/
100
+
.
.
.
+
V
i
×
P
i
/
100
>
X
V_1\times P_1/100+V_2\times P_2/100+...+V_i\times P_i/100 > X
V1×P1/100+V2×P2/100+...+Vi×Pi/100>X
(
V
1
×
P
1
+
V
2
×
P
2
+
.
.
.
+
V
i
×
P
i
)
/
100
>
X
(V_1\times P_1+V_2\times P_2+...+V_i\times P_i)/100 > X
(V1×P1+V2×P2+...+Vi×Pi)/100>X
V
1
×
P
1
+
V
2
×
P
2
+
.
.
.
+
V
i
×
P
i
>
100
X
V_1\times P_1+V_2\times P_2+...+V_i\times P_i > 100X
V1×P1+V2×P2+...+Vi×Pi>100X
这时，我们就可以用前面的思路写代码了。
代码
#include <cstdio>
using namespace std;
int main(int argc, char** argv)
{
int n, x;
scanf("%d%d", &n, &x);
x *= 100;
for(int i=1; i<=n; i++)
{
int v, p;
scanf("%d%d", &v, &p);
x -= v * p;
if(x < 0)
{
printf("%d\n", i);
return 0;
}
}
puts("-1");
return 0;
}
C - Mandarin Orange
题目大意
Takahashi面前有
N
N
N个碗排成一行，从左数第
i
i
i个碗中装有
A
i
A_i
Ai个橙子。
他会选出以个符合下列所有条件的三元组
(
l
,
r
,
x
)
(l,r,x)
(l,r,x)：
- 1 ≤ l ≤ r ≤ N 1\le l\le r\le N 1≤l≤r≤N
- 1 ≤ x ≤ A i 1\le x\le A_i 1≤x≤Ai（ l ≤ i ≤ r l\le i\le r l≤i≤r）
然后，他在第
l
l
l个到第
r
r
r个盘子（包含
l
l
l和
r
r
r）中每个吃掉
x
x
x个橙子。
通过选择三元组
(
l
,
r
,
x
)
(l,r,x)
(l,r,x)以最大化此数目，Takahashi最多可以吃多少个橙子？
1
≤
N
≤
1
0
4
1\le N\le 10^4
1≤N≤104
1
≤
A
i
≤
1
0
5
1\le A_i\le 10^5
1≤Ai≤105
输入格式
N
N
N
A
1
…
A
N
A_1~\dots~A_N
A1 … AN
输出格式
输出一行，即Takahashi最多可以吃的橙子的个数。
样例
样例输入1
6
2 4 4 9 4 9
样例输出1
20
他可以选择 ( l , r , x ) = ( 2 , 6 , 4 ) (l,r,x)=(2,6,4) (l,r,x)=(2,6,4)，能吃 20 20 20个橙子。
样例输入2
6
200 4 4 9 4 9
样例输出2
200
他可以选择 ( l , r , x ) = ( 1 , 1 , 200 ) (l,r,x)=(1,1,200) (l,r,x)=(1,1,200)，能吃 200 200 200个橙子。
分析
很明显，如果我们选择
(
l
,
r
,
x
)
(l,r,x)
(l,r,x)，则Takahashi能吃
(
l
−
r
+
1
)
x
(l-r+1)x
(l−r+1)x个橙子。
我们要让吃的橙子个数最大化，那么选择
(
l
,
r
)
(l,r)
(l,r)后，
x
x
x必定为
min
{
A
l
,
A
l
+
1
,
.
.
.
,
A
r
}
\min\{A_l,A_{l+1},...,A_r\}
min{Al,Al+1,...,Ar}。这样一来，我们就可以枚举
(
l
,
r
)
(l,r)
(l,r)，并记录
min
{
A
l
,
A
l
+
1
,
.
.
.
,
A
r
}
\min\{A_l,A_{l+1},...,A_r\}
min{Al,Al+1,...,Ar}作为
x
x
x，最终输出最小的
(
l
−
r
+
1
)
x
(l-r+1)x
(l−r+1)x。
这个算法的时间复杂度为
O
(
n
2
)
\mathcal O(n^2)
O(n2)。
代码
#include <cstdio>
#define maxn 10005
#define INF 2147483647
using namespace std;
int a[maxn];
inline void setmin(int& a, int b) {if(b < a) a = b;}
inline void setmax(int& a, int b) {if(b > a) a = b;}
int main(int argc, char** argv)
{
int n;
scanf("%d", &n);
for(int i=0; i<n; i++)
scanf("%d", a + i);
int ans = 0;
for(int l=0; l<n; l++)
{
int m = INF;
for(int r=l; r<n; r++)
{
setmin(m, a[r]);
setmax(ans, (r - l + 1) * m);
}
}
printf("%d\n", ans);
return 0;
}
D - Logical Expression
题目大意
给你
N
N
N个字符串
S
1
,
S
2
,
.
.
.
,
S
N
S_1,S_2,...,S_N
S1,S2,...,SN，每个是AND或者OR。
找到符合下列条件的长度为
(
N
+
1
)
(N+1)
(N+1)的元组
(
x
0
,
x
1
,
.
.
.
,
x
N
)
(x_0,x_1,...,x_N)
(x0,x1,...,xN)的数量：
- x i x_i xi是 True \text{True} True或者 False \text{False} False；
- y 0 = x 0 y_0=x_0 y0=x0；
- 当
i
≥
1
i\ge 1
i≥1时：如果
S
i
S_i
Si为
AND， y i = y i − 1 ∧ x i y_i=y_{i-1}\land x_i yi=yi−1∧xi；如果 S i S_i Si为OR，则 y i = y i − 1 ∨ x i y_i=y_{i-1}\lor x_i yi=yi−1∨xi。
在这里， a ∧ b a\land b a∧b表示 a a a与 b b b， a ∨ b a\lor b a∨b表示 a a a或 b b b。
1 ≤ N ≤ 60 1\le N\le 60 1≤N≤60
输入格式
N
N
N
S
1
S_1
S1
⋮
\vdots
⋮
S
N
S_N
SN
输出格式
输出答案。
样例
略，请自行前往AtCoder查看
分析
其实，题目解释得有些复杂了 😦
理解时例如样例
1
1
1：
我们将
f
(
N
)
f(N)
f(N)定义为本题
S
=
{
S
1
,
S
2
,
…
,
S
N
}
S=\{S_1,S_2,\dots,S_N\}
S={S1,S2,…,SN}的答案，则
f
(
N
)
=
{
f
(
N
−
1
)
(
S
N
=
AND
)
f
(
N
−
1
)
×
2
N
(
S
N
=
OR
)
f(N)=\begin{cases} f(N-1) & (S_N=\text{AND})\\ f(N-1)\times2^N & (S_N=\text{OR}) \end{cases}
f(N)={f(N−1)f(N−1)×2N(SN=AND)(SN=OR)
这时，我们就可以在输入时处理答案了。
代码
#include <cstdio>
using namespace std;
int main(int argc, char** argv)
{
int n;
scanf("%d", &n);
char c[4];
long long ans = 1LL, x = 1LL;
while(n--)
{
x <<= 1LL;
scanf("%s", c);
if(c[0] == 'O')
ans ^= x; // 等同于ans += x;这样写速度更快
}
printf("%lld\n", ans);
return 0;
}
扫一扫
734
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
