Just bruteforce

First 8 tests all cords are from -1000 to 1000, maybe it can help somebody)

#include<iostream>

using namespace std;
 int main() {
 string s;
 cin >> s;
 for(auto now : s) cout << 1;
}

Edited by author 14.01.2026 22:14

How to do without palindromic tree???

Don't forget about the stars)

ans >= 2^31

It's strange that 1377 has 295 rating while 1364 has 953 rating. Solutions are almost same)

Given weighted undirected graph, every vertex has its country "C[v]" and money "V[v]". Let's call vertex "v" "responsible" if there exist at least one edge (v, u, cost) where C[v] == C[u]. Also, you can do this operation infinitely many times: Choose edge (v, u, cost), delete it, and add edge (k, u, cost), where C[u] == C[k] and u != k. After this operation make subtraction V[k] -= cost (of course after this operation V[k] must be >= 0). You need to maximize number of responsible vertices

Edited by author 14.08.2024 13:04

What it ask us to do?

Who can explain me the work.

Thanks.

H = 0 or W = 0

#include <iostream>
#include <algorithm>

int main()
{
    int x, y;
    std::cin >> x >> y;
    if ((x + y) & 1)
    {
        std::swap(x, y);
    }
    std::cout << x << " " << y << "\n";
    return 0;
}

Use this two tips:
1) int x = (int)(t * 100 + 0.0000001); // for input
2) cout << setprecision(100); // for output
Good luck :)

If you have wa8, check precision, maybe this will help you. Finally, I did setprecision(100) and get ac. Btw, this task can be solved with one dfs without rerooting.

I tried a lot of variations of self-made stacks but all of them failed. Then I just used 1000 std::stacks with Visual C++ 2022 compiler (not x64) and it worked, using only 640 KB of memory.

Most probably could be solved with centroid decomposition (didn't think much but have some ideas). But my solution is with tree dp with top to bottom dfs and bottom to top dfs. Some call is "rerooting".

Use long type (anything 64 bit)
MST

mst

It ain't a problem to include all the tunnels because apparently they have no cost. So include all of them and then count the number of connected components (let's call it l). The answer is not dependent to the bridges. It is just l-1.