CodeforcesRound#297(Div.2)(ABCDE题解)

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了CodeforcesRound#297(Div.2)(ABCDE题解)，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含15389字，纯文字阅读大概需要22分钟。

内容图文

比赛链接：http://codeforces.com/contest/525 算是比较简单的一场了，拖了好久现在才补 A. Vitaliy and Pie time limit per test：2 seconds memory limit per test：256 megabytes After a hard day Vitaly got very hungry and he wants to eat his favor

比赛链接：http://codeforces.com/contest/525

算是比较简单的一场了，拖了好久现在才补

A. Vitaliy and Pie

time limit per test：2 seconds

memory limit per test：256 megabytes

After a hard day Vitaly got very hungry and he wants to eat his favorite potato pie. But it's not that simple. Vitaly is in the first room of the house with n room located in a line and numbered starting from one from left to right. You can go from the first room to the second room, from the second room to the third room and so on — you can go from the (n?-?1)-th room to the n-th room. Thus, you can go to room x only from room x?-?1.

The potato pie is located in the n-th room and Vitaly needs to go there.

Each pair of consecutive rooms has a door between them. In order to go to room x from room x?-?1, you need to open the door between the rooms with the corresponding key.

In total the house has several types of doors (represented by uppercase Latin letters) and several types of keys (represented by lowercase Latin letters). The key of type t can open the door of type T if and only if t and T are the same letter, written in different cases. For example, key f can open door F.

Each of the first n?-?1 rooms contains exactly one key of some type that Vitaly can use to get to next rooms. Once the door is open with some key, Vitaly won't get the key from the keyhole but he will immediately run into the next room. In other words, each key can open no more than one door.

Vitaly realizes that he may end up in some room without the key that opens the door to the next room. Before the start his run for the potato pie Vitaly can buy any number of keys of any type that is guaranteed to get to room n.

Given the plan of the house, Vitaly wants to know what is the minimum number of keys he needs to buy to surely get to the room n, which has a delicious potato pie. Write a program that will help Vitaly find out this number.

Input

The first line of the input contains a positive integer n (2?≤?n?≤?10⁵) — the number of rooms in the house.

The second line of the input contains string s of length 2·n?-?2. Let's number the elements of the string from left to right, starting from one.

The odd positions in the given string s contain lowercase Latin letters — the types of the keys that lie in the corresponding rooms. Thus, each odd position i of the given string s contains a lowercase Latin letter — the type of the key that lies in room number (i?+?1)?/?2.

The even positions in the given string contain uppercase Latin letters — the types of doors between the rooms. Thus, each even position i of the given string s contains an uppercase letter — the type of the door that leads from room i?/?2 to room i?/?2?+?1.

Output

Print the only integer — the minimum number of keys that Vitaly needs to buy to surely get from room one to room n.

Sample test(s)

Input

3
aAbB

Output

0

Input

4
aBaCaB

Output

3

Input

5
xYyXzZaZ

Output

2

题目大意：有n－1个门大写字母表示，n－1把钥匙小写字母表示，大小写相对应的钥匙能开相对应的门，每次遇到一个钥匙可以将它收起来或者直接使用，用过一次就没了，问最少还要买多少钥匙才能通过所有的门

题目分析：hash存一下，简单模拟

#include 
#include 
int const MAX = 1e6;

char s[MAX];
int hash[60];

int main()
{
    int n, ans = 0;
    scanf("%d %s", &n, s);
    int len = strlen(s);
    memset(hash, 0, sizeof(hash));
    for(int i = 0; i < len; i++)
    {
        if(s[i] >= 'a' && s[i] <= 'z')
            hash[s[i] - 'a'] ++;
        else 
        {
            if(hash[s[i] - 'A'])
                hash[s[i] - 'A'] --;
            else
                ans ++;
        }
    }
    printf("%d\n", ans);
}

B. Pasha and String

time limit per test：2 seconds

memory limit per test：256 megabytes

Pasha got a very beautiful string s for his birthday, the string consists of lowercase Latin letters. The letters in the string are numbered from 1 to |s| from left to right, where |s| is the length of the given string.

Pasha didn't like his present very much so he decided to change it. After his birthday Pasha spent m days performing the following transformations on his string — each day he chose integer a_i and reversed a piece of string (a segment) from position a_i to position |s|?-?a_i?+?1. It is guaranteed that 2·a_i?≤?|s|.

You face the following task: determine what Pasha's string will look like after m days.

Input

The first line of the input contains Pasha's string s of length from 2 to 2·10⁵ characters, consisting of lowercase Latin letters.

The second line contains a single integer m (1?≤?m?≤?10⁵) — the number of days when Pasha changed his string.

The third line contains m space-separated elements a_i (1?≤?a_i; 2·a_i?≤?|s|) — the position from which Pasha started transforming the string on the i-th day.

Output

In the first line of the output print what Pasha's string s will look like after m days.

Sample test(s)

Input

abcdef
1
2

Output

aedcbf

Input

vwxyz
2
2 2

Output

vwxyz

Input

abcdef
3
1 2 3

Output

fbdcea

题目大意：给1个字符串长度为len，要操作m次，每次将第a[i]到第len-a[i]+1这段子串逆置，问最终字符串成什么样

题目分析：用reverse函数肯定T，同一个数操作偶数次相当于没动，所以算出要变换奇数次个数的数，交换即可

#include 
#include 
#include 
using namespace std;
char s[200005];
int a[100005];

int main()
{
    scanf("%s", s + 1);
    int len = strlen(s + 1), m, get;
    scanf("%d", &m);
    while(m--)
    {   
        scanf("%d", &get);
        a[get] ++; 
    }
    for(int i = 1; i <= len / 2; i++)
        a[i] += a[i - 1];
    for(int i = 1; i <= len / 2; i++)
        if(a[i] % 2)
            swap(s[i], s[len + 1 - i]);
    printf("%s\n", s + 1);
}

C. Ilya and Sticks

time limit per test：2 seconds

memory limit per test：256 megabytes

In the evening, after the contest Ilya was bored, and he really felt like maximizing. He remembered that he had a set of n sticks and an instrument. Each stick is characterized by its length l_i.

Ilya decided to make a rectangle from the sticks. And due to his whim, he decided to make rectangles in such a way that maximizes their total area. Each stick is used in making at most one rectangle, it is possible that some of sticks remain unused. Bending sticks is not allowed.

Sticks with lengths a₁, a₂, a₃ and a₄ can make a rectangle if the following properties are observed:

• a₁?≤?a₂?≤?a₃?≤?a₄
• a₁?=?a₂
• a₃?=?a₄

A rectangle can be made of sticks with lengths of, for example, 3 3 3 3 or 2 2 4 4. A rectangle cannot be made of, for example, sticks 5 5 5 7.

Ilya also has an instrument which can reduce the length of the sticks. The sticks are made of a special material, so the length of each stick can be reduced by at most one. For example, a stick with length 5 can either stay at this length or be transformed into a stick of length 4.

You have to answer the question — what maximum total area of the rectangles can Ilya get with a file if makes rectangles from the available sticks?

Input

The first line of the input contains a positive integer n (1?≤?n?≤?10⁵) — the number of the available sticks.

The second line of the input contains n positive integers l_i (2?≤?l_i?≤?10⁶) — the lengths of the sticks.

Output

The first line of the output must contain a single non-negative integer — the maximum total area of the rectangles that Ilya can make from the available sticks.

Sample test(s)

Input

4
2 4 4 2

Output

8

Input

4
2 2 3 5

Output

0

Input

4
100003 100004 100005 100006

Output

10000800015

题目大意：给n个木条，求从中选择4个出来组成长方形，能组成长方形的四个边满足a1<=a2<=a3<=a4，a1=a2，a3=a4，且每根木条的长度可以减1使用，求所能组成的长方形的最大面积

题目分析：从大到小排序，从大的开始选，选的时候注意减1的情况，开始看错题了，以为只拼一个，其实是可以拼多个

#include 
#include 
#include 
#define ll long long
using namespace std;
int const MAX = 1e5;
ll l[MAX];

bool cmp(ll a, ll b)
{
    return a > b;
}

int main()
{
    int n;
    scanf("%d", &n);
    if(n < 4)
    {
        printf("0\n");
        return 0;
    }
    for(int i = 0; i < n; i++)
        scanf("%lld", &l[i]);
    sort(l, l + n, cmp);
    ll a = 0, b = 0, ans = 0;
    for(int i = 0; i < n - 1; i++)
    {
        if(!a && (l[i] == l[i + 1]))
        {
            a = l[i];
            i ++;
            continue;
        }
        else if(!a && (l[i] == l[i + 1] + 1))
        {
            a = l[i + 1];
            i ++;
            continue;
        }
        if(l[i] == l[i + 1])
        {
            b = l[i];
            ans += a * b;
            a = 0;
            b = 0;
            i ++;
        }
        else if(l[i] == l[i + 1] + 1)
        {
            b = l[i + 1];
            ans += a * b;
            a = 0;
            b = 0;
            i ++;
        }
    }
    printf("%lld\n", ans);
}

D. Arthur and Walls

time limit per test：2 seconds

memory limit per test：512 megabytes

Finally it is a day when Arthur has enough money for buying an apartment. He found a great option close to the center of the city with a nice price.

Plan of the apartment found by Arthur looks like a rectangle n?×?m consisting of squares of size 1?×?1. Each of those squares contains either a wall (such square is denoted by a symbol "*" on the plan) or a free space (such square is denoted on the plan by a symbol ".").

Room in an apartment is a maximal connected area consisting of free squares. Squares are considered adjacent if they share a common side.

The old Arthur dream is to live in an apartment where all rooms are rectangles. He asks you to calculate minimum number of walls you need to remove in order to achieve this goal. After removing a wall from a square it becomes a free square. While removing the walls it is possible that some rooms unite into a single one.

Input

The first line of the input contains two integers n,?m (1?≤?n,?m?≤?2000) denoting the size of the Arthur apartments.

Following n lines each contain m symbols — the plan of the apartment.

If the cell is denoted by a symbol "*" then it contains a wall.

If the cell is denoted by a symbol "." then it this cell is free from walls and also this cell is contained in some of the rooms.

Output

Output n rows each consisting of m symbols that show how the Arthur apartment plan should look like after deleting the minimum number of walls in order to make each room (maximum connected area free from walls) be a rectangle.

If there are several possible answers, output any of them.

Sample test(s)

Input

5 5
.*.*.
*****
.*.*.
*****
.*.*.

Output

.*.*.
*****
.*.*.
*****
.*.*.

Input

6 7
***.*.*
..*.*.*
*.*.*.*
*.*.*.*
..*...*
*******

Output

***...*
..*...*
..*...*
..*...*
..*...*
*******

Input

4 5
.....
.....
..***
..*..

Output

.....
.....
.....
.....

题目大意：给一个n*m的矩阵，'' * “表示墙 " . "表示空地，被" * "围起来的是房间现在求删去最少的" * "使得每个房间空地的形状都是一个矩形，输出删除后的矩阵

题目分析：YY一下发现类似下面这种形状的(其他可由它翻转或旋转得到)2*2的子矩阵的" * "都要被改成" . "

*. 
.. 

然后就是预处理一下这种形状BFS搜一下，用队列维护，每次删去一个" * "分别向周围8个方向扩展，注意要用vis数组标记防止未更新的点重复入队列！

#include 
#include 
#include 
using namespace std;
int const MAX = 2005;

int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
char map[MAX][MAX];
bool vis[MAX][MAX];
int n, m;
queue <pair <int, int > > q;

bool judge(int i, int j)
{
    if(map[i][j] == '.' || i == 0 || j == 0 || i == n + 1 || j == m + 1)
        return false;
    if(map[i - 1][j - 1] == '.' && map[i - 1][j] == '.' && map[i][j - 1] == '.')
        return true;
    if(map[i + 1][j + 1] == '.' && map[i + 1][j] == '.' && map[i][j + 1] == '.')
        return true;
    if(map[i + 1][j - 1] == '.' && map[i][j - 1] == '.' && map[i + 1][j] == '.')
        return true;
    if(map[i - 1][j + 1] == '.' && map[i - 1][j] == '.' && map[i][j + 1] == '.')
        return true;
    return false;
}

void BFS()
{
    while(!q.empty())
    {
        int x = q.front().first;
        int y = q.front().second;
        q.pop();
        map[x][y] = '.';
        for(int i = 0; i < 8; i++)
        {
            int xx = x + dx[i];
            int yy = y + dy[i];
            if(judge(xx, yy) && !vis[xx][yy])
            {
                vis[xx][yy] = true;
                q.push(make_pair(xx, yy));
            }
        }
    }
}

int main()
{
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= n; i++)
        scanf("%s", map[i] + 1);
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            if(judge(i, j))
            {
                q.push(make_pair(i, j));
                vis[i][j] = true;
            }
    BFS();
    for(int i = 1; i <= n; i++)
        printf("%s\n", map[i] + 1);
}

E. Anya and Cubes

time limit per test：2 seconds

memory limit per test：256 megabytes

Anya loves to fold and stick. Today she decided to do just that.

Anya has n cubes lying in a line and numbered from 1 to n from left to right, with natural numbers written on them. She also has k stickers with exclamation marks. We know that the number of stickers does not exceed the number of cubes.

Anya can stick an exclamation mark on the cube and get the factorial of the number written on the cube. For example, if a cube reads 5, then after the sticking it reads 5!, which equals 120.

You need to help Anya count how many ways there are to choose some of the cubes and stick on some of the chosen cubes at most k exclamation marks so that the sum of the numbers written on the chosen cubes after the sticking becomes equal to S. Anya can stick at most one exclamation mark on each cube. Can you do it?

Two ways are considered the same if they have the same set of chosen cubes and the same set of cubes with exclamation marks.

Input

The first line of the input contains three space-separated integers n, k and S (1?≤?n?≤?25, 0?≤?k?≤?n, 1?≤?S?≤?10¹⁶) — the number of cubes and the number of stickers that Anya has, and the sum that she needs to get.

The second line contains n positive integers a_i (1?≤?a_i?≤?10⁹) — the numbers, written on the cubes. The cubes in the input are described in the order from left to right, starting from the first one.

Multiple cubes can contain the same numbers.

Output

Output the number of ways to choose some number of cubes and stick exclamation marks on some of them so that the sum of the numbers became equal to the given number S.

Sample test(s)

Input

2 2 30
4 3

Output

1

Input

2 2 7
4 3

Output

1

Input

3 1 1
1 1 1

Output

6

Note

In the first sample the only way is to choose both cubes and stick an exclamation mark on each of them.

In the second sample the only way is to choose both cubes but don't stick an exclamation mark on any of them.

In the third sample it is possible to choose any of the cubes in three ways, and also we may choose to stick or not to stick the exclamation mark on it. So, the total number of ways is six.

题目大意：给n个数a[i]，其中可以选出k个将它变成自己的阶乘，问有多少种方案取出的数的和为s

题目分析：由于n＝25，对每个数有3种情况，不选，选，选它的阶乘，因此3^25肯定T，由此想到类似poj 1840这样的题，我们可以先算前n/2个数然后用map存储下来，再算后n/2个数，在后n/2个数中算出来的数架设为sum2如果s-sum2在前n/2个数的和中出现过，则我们找到相应个数的解，这样将复杂度降到2 * 3^12 约等于1e6的数量级，注意s的范围是10^16，而18! ＝ 6*10^15因此18以后的阶乘我们都不用去算了，搜索的时候当然也不用搜，本地跑了好久，交到cf上才500+ms。。。

#include 
#include 
#include 
#include 

内容总结

以上是互联网集市为您收集整理的CodeforcesRound#297(Div.2)(ABCDE题解)全部内容，希望文章能够帮你解决CodeforcesRound#297(Div.2)(ABCDE题解)所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

---