Codeforces Round #613 (Div. 2)题解

写在前面： 第一次写cf题解，这场难度不大，但只打出两道，难受，还需要认真的学习更多的知识。

A. Mezo Playing Zoma

time limit per test1 second
memory limit per test256 megabytes
inputstandard input
outputstandard output
Today, Mezo is playing a game. Zoma, a character in that game, is initially at position x=0. Mezo starts sending n commands to Zoma. There are two possible commands:

‘L’ (Left) sets the position x:=x−1;
‘R’ (Right) sets the position x:=x+1.
Unfortunately, Mezo’s controller malfunctions sometimes. Some commands are sent successfully and some are ignored. If the command is ignored then the position x doesn’t change and Mezo simply proceeds to the next command.

For example, if Mezo sends commands “LRLR”, then here are some possible outcomes (underlined commands are sent successfully):

“LRLR” — Zoma moves to the left, to the right, to the left again and to the right for the final time, ending up at position 0;
“LRLR” — Zoma recieves no commands, doesn’t move at all and ends up at position 0 as well;
“LRLR” — Zoma moves to the left, then to the left again and ends up in position −2.
Mezo doesn’t know which commands will be sent successfully beforehand. Thus, he wants to know how many different positions may Zoma end up at.

Input
The first line contains n (1≤n≤105) — the number of commands Mezo sends.

The second line contains a string s of n commands, each either ‘L’ (Left) or ‘R’ (Right).

Output
Print one integer — the number of different positions Zoma may end up at.

Example
inputCopy
4
LRLR
outputCopy
5
Note
In the example, Zoma may end up anywhere between −2 and 2.
思路： 很水的签到题，输入一条指令，包涵向左向右的命令，命令会被忽略，求在线段上哪些点可以被走到，稍微画图分析就可以发现是一条连续的线，统计有多少个L，多少个R，R的数目就是右端最远距离，L的数目就是左端最远距离，要记得加上中间的原点。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <string>
 
using namespace std;
 
int main()
{
    string s;
    int n;
    cin >> n >> s;
    long long l = 0, r = 0;
 
    for (int i = 0; i < s.length(); ++i)
    {
        if (s[i] == 'L') l++;
        else r++;
    }
 
    printf("%lld", l + r + 1);
    // getchar(); getchar();
    return 0;
}

B. Just Eat It!

time limit per test1 second
memory limit per test256 megabytes
inputstandard input
outputstandard output
Today, Yasser and Adel are at the shop buying cupcakes. There are n cupcake types, arranged from 1 to n on the shelf, and there are infinitely many of each type. The tastiness of a cupcake of type i is an integer ai. There are both tasty and nasty cupcakes, so the tastiness can be positive, zero or negative.

Yasser, of course, wants to try them all, so he will buy exactly one cupcake of each type.

On the other hand, Adel will choose some segment [l,r] (1≤l≤r≤n) that does not include all of cupcakes (he can’t choose [l,r]=[1,n]) and buy exactly one cupcake of each of types l,l+1,…,r.

After that they will compare the total tastiness of the cupcakes each of them have bought. Yasser will be happy if the total tastiness of cupcakes he buys is strictly greater than the total tastiness of cupcakes Adel buys regardless of Adel’s choice.

For example, let the tastinesses of the cupcakes be [7,4,−1]. Yasser will buy all of them, the total tastiness will be 7+4−1=10. Adel can choose segments [7],[4],[−1],[7,4] or [4,−1], their total tastinesses are 7,4,−1,11 and 3, respectively. Adel can choose segment with tastiness 11, and as 10 is not strictly greater than 11, Yasser won’t be happy 😦

Find out if Yasser will be happy after visiting the shop.

Input
Each test contains multiple test cases. The first line contains the number of test cases t (1≤t≤104). The description of the test cases follows.

The first line of each test case contains n (2≤n≤105).

The second line of each test case contains n integers a1,a2,…,an (−109≤ai≤109), where ai represents the tastiness of the i-th type of cupcake.

It is guaranteed that the sum of n over all test cases doesn’t exceed 105.

Output
For each test case, print “YES”, if the total tastiness of cupcakes Yasser buys will always be strictly greater than the total tastiness of cupcakes Adel buys regardless of Adel’s choice. Otherwise, print “NO”.

Example
inputCopy
3
4
1 2 3 4
3
7 4 -1
3
5 -5 5
outputCopy
YES
NO
NO
Note
In the first example, the total tastiness of any segment Adel can choose is less than the total tastiness of all cupcakes.

In the second example, Adel will choose the segment [1,2] with total tastiness 11, which is not less than the total tastiness of all cupcakes, which is 10.

In the third example, Adel can choose the segment [3,3] with total tastiness of 5. Note that Yasser’s cupcakes’ total tastiness is also 5, so in that case, the total tastiness of Yasser’s cupcakes isn’t strictly greater than the total tastiness of Adel’s cupcakes.
思路： 也是水题，但题意要读清楚，注意Yasser的是所有加起来的权重，Adel是选之中的一部分（而且不能是全部），如果Yasser的权重严格大于Adel的权重，他就会很开心。
总结就是求最小子列和的问题，但因为处理头尾我wa了三发，难受！我记录了最大子列的左端点l，右端点r，防止最大子列就是全部的总和。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <string>
 
using namespace std;
 
long long a[100005];
 
int main()
{
    long long n;
    scanf("%lld", &n);
    while (n--)
    {
        long long k, ans = 0, mans = -1000000009;
        scanf("%lld", &k);
        long long s = 0;
        int f = 0;
        for (int i = 0; i < k; ++i)
        {
            scanf("%lld", &a[i]);
            s += a[i];
        }
        long long l = 0, r = 0;
        long long dif = 0;
        for (int i = 0; i < k; ++i)
        {
            ans += a[i];
            if (ans > mans)
            {
                mans = ans;
                l = dif;
                r = i;
            }
            if (ans <= 0)
            {
                dif = 1 + i;
                ans = 0;
            }
        }
        if (l == 0 && r == k - 1 && mans == s)
        {
            printf("YES\n");
        }
        else if (mans >= s)
            printf("NO\n");
        else
            printf("YES\n");
    }
    // getchar(); getchar();
    return 0;
}

C.Fadi and LCM

time limit per test1 second
memory limit per test256 megabytes
inputstandard input
outputstandard output
Today, Osama gave Fadi an integer X, and Fadi was wondering about the minimum possible value of max(a,b) such that LCM(a,b) equals X. Both a and b should be positive integers.

LCM(a,b) is the smallest positive integer that is divisible by both a and b. For example, LCM(6,8)=24, LCM(4,12)=12, LCM(2,3)=6.

Of course, Fadi immediately knew the answer. Can you be just like Fadi and find any such pair?

Input
The first and only line contains an integer X (1≤X≤1012).

Output
Print two positive integers, a and b, such that the value of max(a,b) is minimum possible and LCM(a,b) equals X. If there are several possible such pairs, you can print any.

Examples
input
2
output
1 2
input
6
output
2 3
input
4
output
1 4
input
1
output
1 1
思路： 知道最小公倍数，求最接近的两个数。
方法不知道，结果想不出来。。。
然后发现很简单，从平方开始找，然后找到一个数可以被整除，然后除数和商的gcd为1.

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <string>

using namespace std;

typedef long long ll;

int main()
{
    long long n, ans;
    scanf("%lld", &n);
    
    for (ll i = 1; i * i <= n; ++i)
        if (n % i == 0 && __gcd(i, n / i) == 1)
            ans = i;
    printf("%lld %lld", ans, n / ans);
    // getchar(); getchar();
    return 0;
}