2023-2024 ICPC Northwestern European Regional Programming Contest (NWERC 2023)

2023-2024 ICPC Northwestern European Regional Programming Contest (NWERC 2023)

K. Klompendans

time limit per test

5 seconds

memory limit per test

1024 megabytes



In traditional Dutch clog dancing, you as the dancer need to follow a very specific sequence of movements. The dance takes place on a square grid of square tiles, and at the start of the dance you stand on the top left corner tile of the grid. You then alternate between two types of dance move, moving from tile to tile in the grid for as long as you want. Your first move may be of either kind, but after that you need to strictly alternate between the two kinds of moves.

Both moves are similar to knight moves in chess: in the first type of move, you go from your current square to a square that is aa tiles away along one axis of the grid and bb tiles away along the other axis. Similarly, in the second type of move, you need to move cc and dd tiles along the respective axes. As you can freely swap the two axes and choose the movement direction along each axis, there can be up to 88 ways of performing a given type of move. Figure K.1 shows an example dance routine with (a,b)=(1,2)(a,b)=(1,2) and (c,d)=(2,3)(c,d)=(2,3).

Figure K.1: Illustration of Sample Input 3, showing a dance that begins in the top left corner of a 4×44×4 grid and ends in the bottom left corner, visiting the blue squares along the way. There are 1313 reachable squares in total. The three squares highlighted in red cannot be part of any dance performance.

Starting on the top left corner tile, how many different tiles could you reach while doing a clog dance? It is not allowed to step outside of the grid and you do not count tiles that you are simply stepping over while doing a move. Note that you need to count all tiles that can be reached during some performance of the dance, but not necessarily during the same one.



Input

The input consists of:

• One line with an integer nn (3≤n≤5003≤n≤500), the side length of the square.
• One line with two integers aa and bb (1≤a,b<n1≤a,b<n), describing the first dance move.
• One line with two integers cc and dd (1≤c,d<n1≤c,d<n), describing the second dance move.



Output

Output the number of tiles you can reach using these dance moves.

Examples

Input

Copy

3
2 1
2 2

Output

Copy

6

Input

Copy

8
1 2
1 2

Output

Copy

64

Input

Copy

4
1 2
2 3

Output

Copy

13

Input

Copy

5
1 2
2 3

Output

Copy

25

Input

Copy

10
3 3
4 4

Output

Copy

50

题目描述： 在一个 n×n 的棋盘中，你从左上角开始，并根据两种不同的“跳跃”规则，跳到不同的格子上。每种跳跃规则类似国际象棋中的马走法。你需要计算在遵循这些跳跃规则的情况下，最多能访问多少个不同的格子。

解题思路：

1. 问题建模：本问题可以建模为一个图遍历问题，其中每个格子是一个节点，每种跳跃方式定义了节点之间的边。

2. 广度优先搜索（BFS）

   ：

   • 通过 BFS 遍历棋盘，从 (1,1) 开始。
   • 按照两种跳跃方式更新所有可以到达的格子。
   • 使用三维数组 vis[x][y][l] 来记录是否访问过 (x, y)，并区分是通过哪种跳跃方式到达的。

3. 最终统计：遍历棋盘，统计所有能到达的格子数量。

复杂度：

• 时间复杂度：O(n2)O(n^2)O(n2)，因为最多遍历棋盘上所有格子。
• 空间复杂度：O(n2)O(n^2)O(n2)。

C++代码实现：

#include <map>
#include <set>
#include <fstream>
#include <queue>
#include <deque>
#include <stack>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdio>
#include <bitset>
#include <iomanip>
#define endl '\n'
#define int long long
#define Max(a, b) (((a) > (b)) ? (a) : (b))
#define Min(a, b) (((a) < (b)) ? (a) : (b))
#define BoBoowen ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;

const int N = 510;
int n, a, b, c, d, ans;
int vis[N][N][3];
struct node
{
    int x;
    int y;
    int l;
};
queue<node> q;

int pd(int x, int y)
{
    if (x > 0 && y > 0 && x <= n && y <= n)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

void dodo(int xx, int yy, int l)
{
    if (pd(xx, yy) == 1 && !vis[xx][yy][l])
    {
        vis[xx][yy][l] = 1;
        q.push({xx, yy, l});
    }
}

void bfs(int x, int y)
{
    q.push({x, y, 0});
    vis[x][y][0] = 1;
    while (!q.empty())
    {
        int xx = q.front().x;
        int yy = q.front().y;
        int ll = q.front().l;
        q.pop();

        if (ll != 1)
        {
            dodo(xx + a, yy + b, 1);
            dodo(xx + a, yy - b, 1);
            dodo(xx - a, yy + b, 1);
            dodo(xx - a, yy - b, 1);
            dodo(xx + b, yy + a, 1);
            dodo(xx + b, yy - a, 1);
            dodo(xx - b, yy + a, 1);
            dodo(xx - b, yy - a, 1);
        }
        if (ll != 2)
        {
            dodo(xx + c, yy + d, 2);
            dodo(xx + c, yy - d, 2);
            dodo(xx - c, yy + d, 2);
            dodo(xx - c, yy - d, 2);
            dodo(xx + d, yy + c, 2);
            dodo(xx + d, yy - c, 2);
            dodo(xx - d, yy + c, 2);
            dodo(xx - d, yy - c, 2);
        }
    }
}

signed main()
{
    BoBoowen;

    cin >> n >> a >> b >> c >> d;
    bfs(1, 1);

    for (int i = 1; i <= n; ++i)
    {
        for (int j = 1; j <= n; ++j)
        {
            if (vis[i][j][0] || vis[i][j][1] || vis[i][j][2])
            {
                ans++;
            }
        }
    }
    cout << ans;
}

---

D. Date Picker

time limit per test

1 second

memory limit per test

1024 megabytes



A filled agenda.

The NWERC is coming up and your agenda is filling up with meetings. One of your teammates wants to plan a meeting, and asks for your input. However, instead of asking you for your exact agenda, you have to fill out two separate polls: one for indicating which days you are available, and one for the hours!

As a computer scientist, you plan your meetings only on whole hours and each meeting takes an integer number of hours. Therefore, your agenda can be modelled as a matrix of 77 rows (days), and 2424 columns (hours). Each cell in this matrix is either ‘.’ or ‘x’, meaning that hour of that day you are either free or have a meeting, respectively.

You have to pick at least dd days in the first poll and hh hours in the second poll, and we assume the meeting will take place on any of your picked hour/day combinations with equal probability. What is the probability that you can attend the meeting if you fill in the polls optimally?



Input

The input consists of:

• 77 lines with 2424 characters, each character being either ‘.’ or ‘x’, with ‘.’ indicating the time slots you are available.
• One line with two integers dd and hh (1≤d≤71≤d≤7, 1≤h≤241≤h≤24), the minimum number of days and hours you have to fill in.



Output

Output the probability that you are available at the chosen meeting time.

Your answer should have an absolute or relative error of at most 10−610−6.

Examples

Input

Copy

xxxxxx..xx..xxxxxxxxxxxx
xxxxxxxxxxxxx....xxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxx
xxxxxx..xx..xxxxxxxxxxxx
xxxxxxxxxxxxx...x..xxxxx
xxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxx
2 5

Output

Copy

0.8

Input

Copy

xxxxxxxxx.....x...xxxxxx
xxxxxxxx..x...x...xxxxxx
xxxxxxxx......x...x.xxxx
xxxxxxxx...xxxxxxxxxxxxx
xxxxxxxx...xxxxxxxxxxxxx
xxxxxxxx...xxxxxxxx.xxxx
......xxxxxxxxxxxxxxxxxx
3 8

Output

Copy

0.958333333333333

题目描述： 你有一个 7 天 × 24 小时的日程表，部分时间不可用（用 x 表示）。你需要从中选择至少 d 天和 h 小时，让可用时间的概率最大化。

解题思路：

1. 组合选择：

   • 枚举所有可能选择的 d 天组合，使用二进制掩码表示哪些天被选中。
   • 对每种组合，计算每小时在这些天的可用次数，并排序。

2. 优化小时选择：

   • 对于每种天组合，从最多可用的小时中选出 h 个。
   • 累加这些小时的总可用次数。

3. 最大化可用概率

   ：

   • 对所有可能的天组合，记录最大的概率。

复杂度：

• 时间复杂度：O(27⋅24⋅7)O(2^7 \cdot 24 \cdot 7)O(27⋅24⋅7)，因为天数最多是 777，组合最多 272^727。

C++代码实现：

#include <map>
#include <set>
#include <fstream>
#include <queue>
#include <deque>
#include <stack>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdio>
#include <bitset>
#include <iomanip>
#define endl '\n'
#define int long long
#define Max(a, b) (((a) > (b)) ? (a) : (b))
#define Min(a, b) (((a) < (b)) ? (a) : (b))
#define BoBoowen ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;

const int D = 7;
const int H = 24;
string tu[8];
int d;
int h;

signed main()
{
    BoBoowen;

    for (int i = 0; i < 7; ++i)
    {
        getline(cin, tu[i]);
    }
    cin >> d >> h;
    // cout << d << h;
    int maxx = 0;
    for (int k = 0; k < (1 << D); ++k)
    {
        int tot = 0;
        for (int j = 0; j < D; ++j)
        {
            if ((k & (1 << j)) != 0)
            {
                tot++;
            }
        }
        if (tot != d)
        {
            continue;
        }

        vector<int> num;
        for (int i = 0; i < H; ++i)
        {
            int tot = 0;
            for (int j = 0; j < D; ++j)
            {
                if ((k & (1 << j)) != 0)
                {
                    if (tu[j][i] == '.')
                    {
                        tot++;
                    }
                }
            }
            num.push_back(tot);
        }
        sort(num.begin(), num.end(), greater<int>());

        int all = 0;
        for (int i = 0; i < h; ++i)
        {
            all += num[i];
        }
        maxx = Max(maxx, all);
    }

    // cout << maxx;
    // cout << (d * h);
    double ans = 1.0 * maxx / (d * h);
    cout << ans;
}

---

L. Lateral Damage

time limit per test

2 seconds

memory limit per test

1024 megabytes



The original Battleships game, before the upgrade to a 100×100100×100 grid. CC BY-NC 3.0 by Pavel Ševela on Wikimedia Commons

You are playing Battleships in a large ocean with large ships. More precisely, there is a large square grid of size at most 100×100100×100 and inside it are up to 1010 of the largest type of ship in Battleships – the aircraft carrier – which has a length of five tiles, placed either horizontally or vertically. The ships do not overlap, but they are allowed to be adjacent to each other. See Figure L.1 for an example.

Unfortunately, your opponent appears to bend the rules to their liking. It looks like they do not always determine the placement of their ships before you start shooting. You are not impressed by their attempt at cheating, and decide to try and win the game anyway.

Figure L.1: Illustration of Sample Interaction 1 after the first four shots were fired.

Your goal is to locate and sink all your opponent’s aircraft carriers in at most 25002500 shots, that is, you must hit each of the five tiles of all their ships.



Interaction

This is an interactive problem. Your submission will be run against an interactor, which reads from the standard output of your submission and writes to the standard input of your submission. This interaction needs to follow a specific protocol:

The interactor first sends one line with two integers nn and kk (5≤n≤1005≤n≤100, 1≤k≤101≤k≤10), the size of the grid and the number of ships. It is guaranteed that it is possible to place kk aircraft carriers in the grid without overlap.

Then, your program needs to start firing shots. Each shot is fired by printing one line of the form “xx yy” (1≤x,y≤n1≤x,y≤n), indicating you shoot at position (x,y)(x,y). The interactor will respond with “hit” if the shot was a hit, “sunk” if the shot caused an aircraft carrier to sink, and “miss” otherwise. If you have shot the same location before, the response will be “miss”.

Once you sink the last aircraft carrier, the interaction will stop and your program must exit.

The interactor is adaptive: the positions of the ships may be determined during the interaction, and may depend on where you decide to shoot.

Make sure you flush the buffer after each write.

A testing tool is provided to help you develop your solution.

Firing more than 25002500 shots will result in a wrong answer.

Example

Input

Copy

7 2

miss

hit

miss

hit

hit

hit

hit

sunk

miss

miss

hit

miss

hit

hit

sunk

Output

Copy

6 1

6 3

7 3

5 3

4 3

3 3

2 3

1 3

6 7

6 7

6 2

6 2

6 4

6 5

6 6

题目描述： 你正在玩一个战舰游戏，目标是在不超过 2500 次射击中找到并击沉所有长度为 5 的战舰。战舰可能是水平或垂直放置的。

解题思路：

1. 基本策略：
   • 按行或列规律性射击，以找到第一个命中的格子。
2. 扩展搜索：
   • 一旦命中，通过在水平和垂直方向上连续射击来确定整艘战舰的位置。
   • 标记命中的部分，避免重复射击。
3. 优化射击顺序：
   • 初始搜索尽可能均匀分布，保证更快发现战舰。
   • 利用战舰长度固定的特性，减少冗余射击。

复杂度：

• 时间复杂度：射击最多 2500 次，保证在限制内完成。

C++代码实现：

#include <map>
#include <set>
#include <fstream>
#include <queue>
#include <deque>
#include <stack>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdio>
#include <bitset>
#include <iomanip>
#define endl '\n'
#define int long long
#define Max(a, b) (((a) > (b)) ? (a) : (b))
#define Min(a, b) (((a) < (b)) ? (a) : (b))
//#define BoBoowen ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;

string s;

signed main()
{
    // BoBoowen;
    int n;
    int kk;
    cin >> n >> kk;

    for (int i = 1; i <= n; ++i)
    {
        for (int j = (i * 2 + 3) % 5 + 1; j <= n; j += 5)
        {
            cout << i << ' ' << j << endl;
            cin >> s;
            if (s == "hit")
            {
                for (int k = Max(1, i - 4); k <= Min(n, i + 4); k++)
                {
                    cout << k << ' ' << j << endl;
                    cin >> s;
                }
                for (int k = Max(1, j - 4); k <= Min(n, j + 4); k++)
                {
                    cout << i << ' ' << k << endl;
                    cin >> s;
                }
            }
        }
    }
    return 0;
}

---

A. Arranging Adapters

time limit per test

4 seconds

memory limit per test

1024 megabytes



You take your laptop out and try to plug it in when you notice that the only socket is already in use. Your friends smirk and reply: “No socket for you, no training for us”. Their smirks quickly fade as you pull out a power strip, unplug the charger from the socket, and plug it back into the power strip. Now, there is enough space for your charger as well.

Figure A.1: Illustration of Sample Input 2. The first six chargers can be plugged in as shown. Note that this is not the only possible solution. However, it can be shown that it is impossible to plug in all seven chargers.

However, as soon as more sockets are available, your friends suddenly take out more devices that need to be charged. You realize that you will not get them to train like this, so you decide to trick them into solving a problem instead.

Your power strip comprises a row of ss sockets, and each socket is 3 cm3 cm in diameter. Furthermore, as you examine the chargers, you notice that they all have integer lengths. The plug of each charger is always on one of the two ends, and each charger can only be used in two orientations. Chargers cannot overlap, but can touch, and can extend beyond the end of the power strip as long as they are plugged in to a socket. Now you challenge them to charge as many devices as possible. This is visualized in Figure A.1. Hoping that this allows them to avoid the training, your friends agree to write a program to solve this.



Input

The input consists of:

• One line with two integers nn and ss (1≤n≤2⋅105(1≤n≤2⋅105, 1≤s≤109)1≤s≤109), the number of chargers you have and the number of sockets on the power strip.
• One line with nn integers ww (3≤w≤1093≤w≤109), the width of each charger in centimetres.

Note that you are allowed to rotate chargers by 180∘180∘before plugging them in.



Output

Output the maximum number of chargers you can plug into the power strip at the same time.

Examples

Input

Copy

5 7
7 4 4 5 8

Output

Copy

5

Input

Copy

8 9
7 4 3 6 4 8 5 6

Output

Copy

6

C++代码实现：

#include <map>
#include <set>
#include <fstream>
#include <queue>
#include <deque>
#include <stack>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdio>
#include <bitset>
#include <iomanip>
#define endl '\n'
#define int long long
#define Max(a, b) (((a) > (b)) ? (a) : (b))
#define Min(a, b) (((a) < (b)) ? (a) : (b))
// #define BoBoowen ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;

const int N = 2 * 1e5 + 10;
int v[N];

signed main()
{
    int n, s;
    cin >> n >> s;

    for (int i = 1; i <= n; ++i)
    {
        cin >> v[i];
    }
    sort(v + 1, v + n + 1);

    int ans = 1;
    int x = 0;
    int y = 0;
    s--;

    if (s != 0)
    {
        for (int i = 1; i < n; ++i)
        {
            s -= v[i] / 3;
            ans++;
            if (v[i] % 3 == 1)
            {
                x++;
            }
            else if (v[i] % 3 == 2)
            {
                y++;
            }

            int zz = 0;
            if (x >= y)
            {
                zz = y + (x - y + 1) / 2;
            }
            else
            {
                zz = y;
            }

            if (zz >= s)
            {
                break;
            }
        }
    }
    cout << ans << endl;
}

H. Higher Arithmetic

time limit per test

4 seconds

memory limit per test

1024 megabytes



Captchas are getting more and more elaborate. It started with doing simple calculations like 7+27+2, and now, it has evolved into having to distinguish chihuahuas from double chocolate chip muffins.

To combat the rise of smarter bots, the Internet Captcha Production Company (ICPC) has outdone itself this time: given a distorted image containing many integers, find the maximum value that can be expressed using each of the given integers exactly once, using addition, multiplication, and arbitrary parentheses.

After unsuccessfully trying to solve such a captcha for an hour straight, Katrijn is terribly frustrated. She decides to write a program that outputs a valid arithmetic expression with maximal value.

Input

The input consists of:

• One line with an integer nn (1≤n≤1051≤n≤105), the number of integers in the captcha.
• One line with nn integers aa (1≤a≤1061≤a≤106), the integers in the captcha.

Output

Output a valid arithmetic expression with maximal value, where each integer from the input list is used exactly once. The usual order of operations applies. The output expression may use at most 106106 characters and must not contain any spaces. Such an expression exists for any possible input.

If there are multiple valid solutions, you may output any one of them.

Examples

Input

Copy

4
1 2 3 4

Output

Copy

3*((1+2)*4)

Input

Copy

3
13 37 1

Output

Copy

(1+13)*37

Input

Copy

4
1 1 1 1

Output

Copy

((1+1)*(1+1))

给定一组数字，要求使用 +, *, (, ) 等算符，构造一个有效的算术表达式，其中每个给定的数字只能使用一次，并且使得该表达式的值最大。

解题思路：

1. 最大表达式的形式：为了得到最大的值，最佳的表达式通常是“和的乘积”。
2. 所有数字大于1：如果所有的数字都大于1，最简单的做法就是将所有数字相乘。
3. 包含1和2时：如果表达式中包含了1和2，我们需要将某些数字组合成和，然后再进行乘法运算，以得到更大的结果。
4. 具体情况分析：
   • 仅有一个1：如果只有一个1，我们可以将它加到第二小的数字上。
   • 没有2的情况：如果没有2，我们可以将三个1组合在一起，形成更大的乘积。
   • 特殊情况：如果有两个1或者四个1，最优的做法是将两个1组合在一起。
   • 至少有1和2：在这种情况下，可以反复将1和2组合，以便形成更大的值。
   • 特殊组合：如果有两个1和一个2，最好将它们组合在一起。

解决步骤：

1. 将所有数字大于1的部分直接相乘。

2. 对于1和2的组合情况

   ，根据具体数量和分布选择合适的组合方式：

   • 如果只有一个1，将它加到第二小的数字上。
   • 如果没有2，可以将三个1组合成一个加法式子。
   • 如果有多个1，可以选择将它们按最优的方式进行组合，如将两个1合并。
   • 如果有1和2，应该通过组合1和2来优化结果。

#include <bits/stdc++.h>
using namespace std;

const int N = 100005;
int n;
int a[N], b[N], m;
int num, cnt;

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a[i]);
        if (a[i] == 1)
            num++;
        else if (a[i] == 2)
            cnt++;
        else
            b[++m] = a[i];
    }

    if (num == 0)
    {
        printf("%d", a[1]);
        for (int i = 2; i <= n; i++)
            printf("*%d", a[i]);
        return 0;
    }

    sort(b + 1, b + m + 1);
    for (int i = 1; i <= m / 2; i++)
        swap(b[i], b[m - i + 1]);

    if (num == 1)
    {
        while (cnt)
        {
            cnt--;
            b[++m] = 2;
        }
        if (m == 0)
        {
            printf("1");
        }
        else
        {
            for (int i = 1; i < m; i++)
                printf("%d*", b[i]);
            printf("(%d+1)", b[m]);
        }
        return 0;
    }

    if (cnt == 0)
    {
        if (num % 3 == 0)
        {
            for (int i = 1; i <= m; i++)
                printf("%d*", b[i]);
            printf("(1+1+1)");
            for (int i = 4; i <= num; i += 3)
                printf("*(1+1+1)");
        }
        else if (num % 3 == 1)
        {
            for (int i = 1; i <= m; i++)
                printf("%d*", b[i]);
            printf("(1+1)*(1+1)");
            for (int i = 5; i <= num; i += 3)
                printf("*(1+1+1)");
        }
        else if (num % 3 == 2)
        {
            for (int i = 1; i <= m; i++)
                printf("%d*", b[i]);
            printf("(1+1)");
            for (int i = 3; i <= num; i += 3)
                printf("*(1+1+1)");
        }
        return 0;
    }

    int t = min(cnt, num);
    t--;
    num -= t;
    cnt -= t;
    if (t)
    {
        for (int i = 1; i <= t; i++)
            printf("(1+2)*");
    }
    while (cnt)
    {
        b[++m] = 2;
        cnt--;
    }

    if (num == 0)
    {
        for (int i = 1; i < m; i++)
            printf("%d*", b[i]);
        printf("%d", b[m]);
    }
    else if (num % 3 == 0)
    {
        for (int i = 1; i <= m; i++)
            printf("%d*", b[i]);
        printf("(1+1+1)");
        for (int i = 4; i <= num; i += 3)
            printf("*(1+1+1)");
    }
    else if (num % 3 == 1)
    {
        for (int i = 1; i < m; i++)
            printf("%d*", b[i]);
        printf("(%d+1)", b[m]);
        for (int i = 2; i <= num; i += 3)
            printf("*(1+1+1)");
    }
    else if (num % 3 == 2)
    {
        for (int i = 1; i <= m; i++)
            printf("%d*", b[i]);
        printf("(1+1)");
        for (int i = 3; i <= num; i += 3)
            printf("*(1+1+1)");
    }

    return 0;
}