2020.5.4-ICPC Pacific Northwest Regional Contest 2019

Posted 2020-12-15 mxw000120

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了2020.5.4-ICPC Pacific Northwest Regional Contest 2019相关的知识，希望对你有一定的参考价值。

A. Radio Prize

All boring tree-shaped lands are alike, while all exciting tree-shaped lands are exciting in their own special ways.What makes Treeland more exciting than the other tree-shaped lands are the raddest radio hosts in the local area: Rootand Leaf. Every morning on FM 32:33 (repeating of course), Root and Leaf of The Full Depth Morning Show serveup the hottest celebrity gossip and traffic updates.

The region of Treeland is made of $u_iui? and v_ivi?, and has a toll of w_iwi?.$

To reward their loyal listeners, The Full Depth Morning Show is giving away a number of travel packages! Root andLeaf will choose

Each city in Treeland has its own tax on prizes: $t_iti?. Let d_{u,v}du,v?be the sum of the tolls on each road on the only simplepath from city uu to vv. For a trip from city uu to city vv, the cost of that trip is then (t_u + t_v)d_{u,v}(tu?+tv?)du,v?.$

The shock jocks haven’t quite thought through how much their prize is worth. They need to prepare a report to theradio executives, to summarize the expected costs. For each city that could win the prize, what is the total cost ofpurchasing all the tickets?

input

The first line of input is a single integer n (1 $t_iti?(1 leq t_i leq 1 0001≤ti?≤1000), the tax in each city. The following n - 1n−1 lines each have 3 integers, u_i,v_i,w_iui?,vi?,wi?, meaning the iith roadconnects cities u_iui? and v_ivi?(1 leq u_i,v_i leq n1≤ui?,vi?≤n), with a toll of w_iwi? (1 leq w_i leq 1 0001≤wi?≤1000).$

output

Output

样例输入

5

样例输出

样例输入2

6
4 3 3 4 3 3
1 3 2
2 1 1
1 4 6
4 5 6
6 4 2

样例输出2

#include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <utility>

using namespace std;

using ll = long long;
using pii = pair<int, int>;

constexpr int MAXN = 100000;
int n;
int t[MAXN];
vector<pii> tree[MAXN];

int depth[MAXN];
int sz[MAXN];
ll tsum[MAXN];
ll ans[MAXN];

void dfs1(int u, int p) {
    sz[u] = 1;
    tsum[u] = t[u];
    for (auto& e : tree[u]) {
        int v, w;
        tie(v, w) = e;

        if (v == p) continue;

        depth[v] = depth[u] + w;

        dfs1(v, u);

        sz[u] += sz[v];
        tsum[u] += tsum[v];
    }
}

void dfs2(int u, int p, ll depth_sum, ll tax_depth_sum) {
    ans[u] = t[u] * depth_sum + tax_depth_sum;
    for (auto& e : tree[u]) {
        int v, w;
        tie(v, w) = e;
        if (v == p) continue;

        dfs2(
            v,
            u,
            depth_sum + w * (n - 2 * sz[v]),
            tax_depth_sum + w * (tsum[0] - 2 * tsum[v])
        );
    }
}

int main() {
    cin >> n;

    for (int i = 0; i < n; ++i) {
        cin >> t[i];
    }

    for (int i = 1; i < n; ++i) {
        int u, v, w;
        cin >> u >> v >> w;
        --u; --v;
        tree[u].emplace_back(v, w);
        tree[v].emplace_back(u, w);
    }

    dfs1(0, -1);
    ll depth_sum = 0;
    ll tax_depth_sum = 0;
    for (int i = 0; i < n; ++i) {
        depth_sum += depth[i];
        tax_depth_sum += 1LL * t[i] * depth[i];
    }

    dfs2(0, -1, depth_sum, tax_depth_sum);

    for (int i = 0; i < n; ++i) {
        cout << ans[i] << ‘
‘;
    }

    return 0;
}

B. Perfect Flush

You are given a list of integers $x_1,x_2,ldots,x_nx1?,x2?,…,xn? and a number kk. It is guaranteed that each i from 1 to k appears in thelist at least once.Find the lexicographically smallest subsequence of x that contains each integer from 1 to k exactly once.$

input

The first line will contain two integers $x_ixi? with 1 leq x_i leq k1≤xi?≤k.$

output

Write out on one line, separated by spaces, the lexicographically smallest subsequence of x that has each integer from 1 to k exactly once

样例输入1

样例输出1

2 1 3

样例输入2

样例输出2

3 2 1 4 5

#include <iostream>
#include <map>
#include <vector>
using namespace std ;
int main() {
   int n, k ;
   cin >> n >> k ;
   vector<int> v(n) ;
   for (auto &a : v) {
      cin >> a ;
      a-- ;
   }
   vector<int> r ;
   vector<char> seen(k) ;
   vector<int> nextlast(n) ;
   vector<int> next(n) ;
   vector<int> nextlink(k) ;
   for (auto &e : nextlink)
      e = -1 ;
   for (int i=n-1; i>=0; i--) {
      int e = v[i] ;
      next[i] = nextlink[e] ;
      nextlink[e] = i ;
   }
   int st = 0 ;
   int need = k ;
   int at = n ;
   int ptr = n ;
   while (need > 0 && at > 0) {
      at-- ;
      if (seen[v[at]] == 0) {
         nextlast[at] = ptr ;
         ptr = at ;
         seen[v[at]] = 2 ;
         need-- ;
      }
   }
   map<int, int> loc ;
   for (int i=0; i<=at; i++)
      if (loc.find(v[i]) == loc.end())
         loc[v[i]] = i ;
   while ((int)r.size() < k) {
      int smi = loc.begin()->second ;
      r.push_back(v[smi]) ;
      seen[v[smi]] = 1 ;
      loc.erase(v[smi]) ;
      while (at < n && seen[v[at]] == 1) {
         int nat = nextlast[at] ;
         for (int i=at+1; i<n && i<=nat; i++)
            if (seen[v[i]] != 1 && loc.find(v[i]) == loc.end())
               loc[v[i]] = i ;
         at = nat ;
      }
      while (st <= smi) {
         if (seen[v[st]] == 2) {
            int nv = next[st] ;
            if (nv >= 0 && nv <= at) {
               loc[v[st]] = nv ;
            } else {
               loc.erase(v[st]) ;
            }
         }
         st++ ;
      }
   }
   for (int i=0; i<(int)r.size(); i++) {
      if (i)
         cout << " " ;
      cout << (1+r[i]) ;
   }
   cout << endl ;
}

C. Coloring Contention

技术图片

Alice and Bob are playing a game on a simple connected graph with N nodes and M edges.Alice colors each edge in the graph red or blue.A path is a sequence of edges where each pair of consecutive edges have a node in common. If the first edge in thepair is of a different color than the second edge, then that is a “color change.”After Alice colors the graph, Bob chooses a path that begins at node 1 and ends at node N. He can choose any path onthe graph, but he wants to minimize the number of color changes in the path. Alice wants to choose an edge coloringto maximize the number of color changes Bob must make. What is the maximum number of color changes she canforce Bob to make, regardless of which path he chooses?

Input

The first line contains two integer values N and M with $a_iai? and b_ibi? indicating an undirected edge between nodes a_iai? and b_ibi? (1 leq a_i,b_i leq N1≤ai?,bi?≤N, a_i eq b_iai??=bi?).All edges in the graph are unique.$

Output

Output the maximum number of color changes Alice can force Bob to make on his route from node 1 to node N

样例输入1

样例输出1

样例输入2

样例输出2

// #include <bits/stdc++.h> // this is not C++; this is a Linuxism
#include <iostream>
#include <vector>
#include <queue>

using namespace std;

#define all(x) begin(x), end(x)

using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using vi = vector<int>;

int main() {
    int n, m;
    cin >> n >> m;
    vector<vi> graph(n);
    for (int i = 0; i < m; ++i) {
        int u, v;
        cin >> u >> v;
        --u; --v;

        graph[u].push_back(v);
        graph[v].push_back(u);
    }

    vi dist(n, n + 1);
    dist[0] = 0;
    queue<int> q;
    q.push(0);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int v : graph[u]) {
            if (dist[v] == n + 1) {
                dist[v] = dist[u] + 1;
                q.push(v);
            }
        }
    }

    cout << dist.back() - 1 << ‘
‘;

    return 0;
}

D. Dividing by Two

You are given two integers, A and B. You want to transform A to B by performing a sequence of operations. You canonly perform the following operations:

Divide A by two, but only if A is even
Add one to A.

What is the minimum number of operations you need to transform A into B?

input

The input will be a single line containing two integers A and B with $10^91≤A,B≤109.$

output

On a single line write the minimum number of operations required as an integer.

样例输入1

103 27

样例输出1

样例输入2

3 8

样例输出2

#include<bits/stdc++.h>
using namespace std;
int main()
{
    long long n,m,ct;
    while(scanf("%lld%lld",&n,&m)!=EOF)
    {
        ct=0;
        if(n==m)cout<<"0"<<endl;
        else
        {
            if(n<m)
            {
                while(n!=m)
                {
                    n+=1;
                    ct++;
                }
                cout<<ct<<endl;
            }
            else if(n>m)
            {
                    while(n>m)
                    {
                        if(n%2==0)
                      {
                        n/=2;
                        ct++;
                      }
                      else {
                        n+=1;
                        ct++;
                      }
                    }
                      while(n<m) {
                        n+=1;
                        ct++;
                      }
                   cout<<ct<<endl;
                }

        }
    }
}

E. Rainbow Strings

Define a string to be a rainbow string if every letter in the string is distinct. An empty string is also considered a rainbow string.

Given a string of lowercase letters, compute the number of different subsequences which are rainbow strings. Two subsequences are different if an index is included in one subsequence but not the other, even if the resulting strings areidentical.

In the first example, there are 8 subsequences. The only subsequences that aren‘t rainbow strings are

input

The input will consist of a single line with a single string consisting solely of lowercase letters. The length of the stringis between 1 and 100 000 (inclusive).

output

Write on a single line the number of rainbow sequences, modulo the prime 11092019.

样例输入1

aab

样例输出1

样例输入2

icpcprogrammingcontest

样例输出2

#include <iostream>
#include <vector>
#include <string>
using namespace std ;
typedef long long ll ;
ll MOD = 11092019 ;
int main() {
   string s ;
   cin >> s ;
   vector<int> cnt(256) ;
   for (auto c : s)
      cnt[(int)c]++ ;
   ll r = 1 ;
   for (auto v : cnt)
      r = (r * (v + 1)) % MOD ;
   cout << r << endl ;
}

F. Carny Magician

Charles and Ada are watching a magician shuffling a deck of thirteen numbered cards, which were originally ordered.The magician spreads the cards out on the table.

Ada exclaims, “Odd; ten of the cards are in their original locations!”

Charles thinks for a moment, and says, “Not only that, but it is the forty-second such ordering!”

Can you figure out the order of the cards? Formally, the magician’s cards can be considered as a permutation $p_1, p_2, ..., p_np1?,p2?,...,pn?, that contains each number from 1 to nn exactlyexactly once. The number of fixed points is the number ofindices ii such that p_i = ipi?=i.$

Given three numbers

Input

The input will be a single line containing the three integers $10^{18}1≤k≤1018.$

Output

On a single line, write the permutation as a sequence of

样例输入1

3 1 1

样例输出1

1 3 2

样例输入2

3 2 1

样例输出2

-1

样例输入3

5 3 7

样例输出3

2 1 3 4 5

G. Glow, Little Pixel, Glow

An LCD panel is composed of a grid of pixels, spaced

A pixel will activate, turning dark, when a current is present along both the vertical and horizontal wire passing through that pixel.

For a period of time, we will send pulses of current down selected wires. The current flows down the wires at a speedof one alu per atu (“arbitrary time unit”). The pulses themselves have a length measured in atus. A pixel activates when current is passing through both intersecting wires at the same time. If the leading edge of a pulse on one wirereaches the intersection at the exact same time that the trailing edge of a pulse on the other wire leaves that intersection,the pixel is not activated.

All pulses in vertical wires start from the bottom of the grid. All pulses in horizontal wires start from the left of the grid. At most one pulse will travel along any one wire.

Given the schedule of pulses to be sent through the wires, determine how many pixels will have been activated by the time all pulses have exited the top and right of the grid.

Input

The first line will contain

A single character that is either ‘h’ or ‘v’, indicating the horizontal/vertical direction of the pulse.
An integer t,
An integer m,
An integer

Output

Print on a single line the number of pixels that will have activated by the time the last pulse of current has left the grid.

样例输入1

样例输出1

样例输入2

样例输出2

样例输入3

样例输出3

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std ;
typedef long long ll ;
struct traininfo {
   int tim, end ;
   char typ ;
} ;
bool operator<(const traininfo &a, const traininfo &b) {
   if (a.tim != b.tim)
      return a.tim < b.tim ;
   if (a.end != b.end)
      return a.end < b.end ;
   return a.typ < b.typ ;
}
int main() {
   int n ;
   cin >> n ;
   vector<traininfo> sortme ;
   for (int i=0; i<n; i++) {
      char typ ;
      int t0, len, coor ;
      cin >> typ >> t0 >> len >> coor ;
      sortme.push_back({t0-coor, 1, typ}) ;
      sortme.push_back({t0-coor+len, -1, typ}) ;
   }
   sort(sortme.begin(), sortme.end()) ;
   ll rr = 0 ;
   ll hcnt = 0, vcnt = 0 ;
   for (auto v : sortme) {
      if (v.typ == ‘h‘) {
         hcnt += v.end ;
         if (v.end > 0) {
            rr += vcnt ;
         }
      } else {
         vcnt += v.end ;
         if (v.end > 0)
            rr += hcnt ;
      }
   }
   cout << rr << endl ;
}

H. Pivoting Point

Consider a set of points

Choose a point

Slowly rotate the line clockwise like a windmill about the point

Continue this process until the line has rotated a full

During this process, a given point can be promoted multiple times. Considering all possible starting pivots and orientations, find the maximum number of times that a single point can be promoted during a single

Input

The first line of the input will be a single integer $x_ixi? and y_iyi? with -10 000 ≤ xi,yi ≤ 10 000−10000≤xi,yi≤10000.$

Output

On one line, write an integer with the largest number of times any particular point can be a pivot when an arbitrarystarting line does a full rotation as described above.

样例输入1

样例输出1

样例输入2

样例输出2

#include <iostream>
#include <vector>
using namespace std ;
using ll = long long ;
const ll INF = 2‘000‘000‘000‘000‘000‘000LL ;
ll add(ll a, ll b) {
   ll c = a + b ;
   if (c >= INF)
      return INF ;
   return c ;
}
ll mul(ll a, ll b) {
   if (b > 0 && a > INF / b)
      return INF ;
   return a * b ;
}
const int MAX = 128 ;
ll c[MAX][MAX], f[MAX], g[MAX][MAX] ;
ll g3(ll n, ll m, ll x) {
   return mul(c[x][m], g[n-m][x-m]) ;
}
int main(int argc, char *argv[]) {
   f[0] = 1 ;
   for (int i=1; i<MAX; i++)
      f[i] = mul(f[i-1], i) ;
   for (int i=0; i<MAX; i++) {
      c[i][0] = c[i][i] = 1 ;
      for (int j=1; j<i; j++)
         c[i][j] = add(c[i-1][j-1], c[i-1][j]) ;
   }
   for (int i=0; i<MAX; i++) {
      g[i][0] = f[i] ;
      g[i][1] = mul(i-1, g[i-1][0]) ;
      for (int j=2; j<=i; j++)
         g[i][j] = add(mul(j-1, g[i-1][j-2]), mul(i-j, g[i-1][j-1])) ;
   }
   ll n, p, k ;
   cin >> n >> p >> k ;
   vector<char> used(n) ;
   ll matchable = n ;
   ll thiscnt = 0 ;
   k-- ;
   if (g3(n, p, n) <= k)
      cout << -1 ;
   else
      for (int pos=0; pos<n; pos++) {
         matchable -= !used[pos] ;
         for (int dig=0; dig<n; dig++) {
            if (used[dig])
               continue ;
            if (p == 0 && dig == pos)
               continue ; // no more matches available
            thiscnt = g3(n-pos-1, p-(dig==pos), matchable-(dig>pos)) ;
            if (thiscnt > k) {
               if (pos)
                  cout << " " ;
               cout << (dig + 1) ;
               if (dig > pos)
                  matchable-- ;
               if (dig == pos)
                  p-- ;
               used[dig]++ ;
               break ;
            } else
               k -= thiscnt ;
         }
      }
   cout << endl ;
}

I. Error Correction

You are given

Input

The first line of input contains an integer

Output

Output the size of the largest swap-free set

样例输入1

6
abc
acb
cab
cba
bac
bca

样例输出1

样例输入2

11
alerts
alters
artels
estral
laster
ratels
salter
slater
staler
stelar
talers

样例输出2

样例输入3

6
ates
east
eats
etas
sate
teas

样例输出3

#include <climits>
#include <iostream>
#include <map>
#include <vector>
#include <string>
using namespace std ;
int bc(int v) {
   int r = 0 ;
   while (v) {
      r++ ;
      v &= v-1 ;
   }
   return r ;
}
int calcparity(const string &s) {
   int seen = 0 ;
   int p = 0 ;
   for (auto c : s) {
      c -= ‘a‘ ;
      p += bc(((1<<c)-1) & seen) ;
      seen |= 1<<c ;
   }
   return p&1 ;
}
int diff(const string &a, const string &b) {
   int r = 0 ;
   for (int i=0; i<(int)a.size(); i++)
      r += (a[i] != b[i]) ;
   return r ;
}
struct e {
   int v, flow, c, rev ;
} ;
struct g {
   int v ;
   vector<vector<e>> adj ;
   vector<int> level ;
   g(int v_) : v(v_), adj(v_), level(v_) {}
   void addedge(int a, int b, int c) {
      e ab {b,0,c,(int)adj[b].size()} ;
      e ba {a,0,0,(int)adj[a].size()} ;
      adj[a].push_back(ab) ;
      adj[b].push_back(ba) ;
   }
   int bfs(int s, int t);
   int sendflow(int s, int flow, int t, vector<int> &ptr) ;
   int dinic(int s, int t) ;
} ;
int g::bfs(int s, int t) {
   for (auto &v : level)
      v = -1 ;
   level[s] = 0 ;
   vector<int> q ;
   q.push_back(s) ;
   for (int qg=0; qg<(int)q.size(); qg++) {
      int a = q[qg] ;
      for (auto &e:adj[a])
         if (level[e.v] < 0 && e.flow < e.c) {
            level[e.v] = level[a]+1 ;
            q.push_back(e.v) ;
         }
   }
   return level[t] >= 0 ;
}
int g::sendflow(int a, int flow, int t, vector<int> &start) {
   if (a == t)
      return flow ;
   for (; start[a]<(int)adj[a].size(); start[a]++) {
      e &e = adj[a][start[a]] ;
      if (level[e.v] == level[a]+1 && e.flow < e.c) {
         int curf = min(flow, e.c-e.flow) ;
         int tempf = sendflow(e.v, curf, t, start) ;
         if (tempf > 0) {
            e.flow += tempf ;
            adj[e.v][e.rev].flow -= tempf ;
            return tempf ;
         }
      }
   }
   return 0 ;
}
int g::dinic(int s, int t) {
   if (s == t)
      return -1 ;
   int tot = 0 ;
   vector<int> start(v+1) ;
   while (bfs(s, t)) {
      for (auto &v : start)
         v = 0 ;
      while (int f=sendflow(s, INT_MAX, t, start))
         tot += f ;
   }
   return tot ;
}
int main() {
   int n ;
   cin >> n ;
   vector<string> w(n) ;
   for (auto &v : w)
      cin >> v ;
   vector<int> parity(n) ;
   for (int i=0; i<(int)w.size(); i++)
      parity[i] = calcparity(w[i]) ;
   g graph(n+2) ;
   for (int i=0; i<(int)parity.size(); i++) {
      if (parity[i])
         graph.addedge(i+2, 1, 1) ;
      else {
         graph.addedge(0, i+2, 1) ;
         for (int j=0; j<(int)parity.size(); j++)
            if (parity[j] && diff(w[i], w[j]) == 2)
               graph.addedge(i+2, j+2, 1) ;
      }
   }
   int f = graph.dinic(0, 1) ;
   int r = n - f ;
   cout << r << endl ;
}

J. Interstellar Travel

You are planning to travel in interstellar space in the hope of finding habitable planets. You have already identified

Space is modeled as a $T_iTi? distance if the spaceship is launched at an angle of a_iai? with the xx-axis. If the angle is not perfectly aligned, then the spaceship gets less energy. Specifically, if the launch direction makes an angle of aa with the xx-axis, then it gets enough energy to travel distance of$

$T_i-s_i * dist(a_i,a))max(0,Ti?−si?∗dist(ai?,a))$

from star

Input

The first line contains the value $10^51≤N≤105. Following this are NN lines each containing three real numbers T_iTi?,s_isi?, and a_iai?, with 0 < T_i ≤ 1 0000<Ti?≤1000, 0 ≤ si ≤ 1000≤si≤100, and 0 ≤ a_i < 2pi0≤ai?<2π. All real numbers in the input have at most 66 digits after the decimal point.$

Output

On a single line output the maximum distance the spacecraft can travel. Your answer is considered correct if it has anabsolute or relative error of at most $10^{−6}10−6.$

本题答案不唯一，符合要求的答案均正确

样例输入1

2
100 1 1
100 1 1.5

样例输出1

199.500000

样例输入2

4
100 1 0.5
200 1 1
100 0.5 1.5
10 2 3

样例输出2

405.500000

#include <iostream>
#include <vector>
#include <algorithm>
#define _USE_MATH_DEFINES
#include <math.h>

#define f first
#define s second

using namespace std;

typedef long long ll;
typedef pair<double, ll> di;
typedef vector<di> vdi;
typedef vector<double> vd;
typedef pair<double, double> dd;
typedef vector<dd> vdd;

int main() {
    ll N;
    cin >> N;
    vd T(N), s(N);
    vd a(N);
    for (ll i = 0; i < N; ++i) {
        cin >> T[i] >> s[i] >> a[i];
    }

    vdd dist_deriv;
    double cur = 0;
    for (ll i = 0; i < N; ++i) {
        if (s[i] != 0 && T[i]/s[i] < M_PI) {
            dist_deriv.emplace_back(a[i] - T[i]/s[i], s[i]);
            dist_deriv.emplace_back(a[i], -s[i]*2);
            dist_deriv.emplace_back(a[i] + T[i]/s[i], s[i]);

            dist_deriv.emplace_back(a[i] - T[i]/s[i] + 2*M_PI, s[i]);
            dist_deriv.emplace_back(a[i] + 2*M_PI, -s[i]*2);
            dist_deriv.emplace_back(a[i] + T[i]/s[i] + 2*M_PI, s[i]);
        } else {
            cur += T[i] - s[i]*M_PI;
            dist_deriv.emplace_back(a[i] - M_PI, s[i]);
            dist_deriv.emplace_back(a[i], -s[i]*2);
            dist_deriv.emplace_back(a[i] + M_PI, 2*s[i]);
            dist_deriv.emplace_back(a[i] + 2*M_PI, -s[i]*2);
            dist_deriv.emplace_back(a[i] + 3*M_PI, s[i]);
        }
    }

    sort(dist_deriv.begin(), dist_deriv.end());

    double last_angle = dist_deriv[0].f;
    double best = cur;
    double c_deriv = 0;

    for (ll i = 0; i < dist_deriv.size(); ++i) {
        cur += c_deriv * (dist_deriv[i].f - last_angle);
        c_deriv += dist_deriv[i].s;
        last_angle = dist_deriv[i].f;
        best = max(best, cur);
    }

    printf("%.6lf
", best);
}

K. Computer Cache

Your computer has a cache consisting of $i^{th}ith byte is denoted as a_iai?. Initially all cache bytes start off with the value zero. Formally, the cache can bemodeled by a byte array of length nn that is initially all zeros.$

You have $i^{th}ith piece of data is a byte array x_ixi? of length s_isi?.You are going to do qq different operations on your computer. There are three types of operations:$

Load data $a_p = x_{i,1}, a_{p+1} = x_{i,2},...,a_{p+s_i-1} =x_{i,s_i}ap?=xi,1?,ap+1?=xi,2?,...,ap+si?−1?=xi,si??, where x_{i,k}xi,k? represents the kkth byte of the array x_ixi?. This overwrites any previously stored value in thecache. It is guaranteed that this is a valid operation (e.g. s_i + p - 1 ≤ nsi?+p−1≤n). It is possible for multiple versions of some data to be loaded in multiple positions at once.$

Print the byte that is stored in address

Increment the $l^{th}lth through r^{th}rth bytes in the i^{th}ith piece of data, modulo 256. Formally, this means to set x_{i,k} =(x_{i,k} + 1)xi,k?=(xi,k?+1) mod 256256 for l ≤ k ≤ rl≤k≤r. This does not affect values that are already loaded in the cache and only affects future loads.$

Input

The first line of input consists of three numbers $5*10^51≤n,m,q≤5∗105, Sigma_i s_i le 5*10^5Σi?si?≤5∗105,s_i ge 1si?≥1,0 le x_{i,j} le 2550≤xi,j?≤255$

Output

Your program must output the results for each type 2 operation, one integer value per line.

样例输入

样例输出

样例解释

2 1 Nothing has been put into the cache, so print 0

1 2 2 The cache is now [0, 1, 2, 1, 3]

1 1 1 The cache is now [255, 0, 15, 1, 3]

2 1 Print the first value of the cache which is 255

2 4 Print the fourth value of the cache which is 1

3 1 1 2 The first piece of data becomes [0, 1, 15]. The cache is still [255, 0, 15, 1, 3]

2 1 Print the first value of the cache which is 255.

1 1 2 The cache becomes [255, 0, 1, 15, 3].

2 2 Print the second value of the cache which is 0.

2 5 Print the fifth value of the cache which is 3.

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std ;
struct quad {
   int cmd, i, p, r ;
} ;
template<typename T> struct BIT {
   BIT<T>(int n=0) { resize(n) ; }
   void resize(int n) {
      sz = n ;
      arr.resize(4*n+1) ;
   }
   void dorange(int a, int b, int v) {
      while (a < b) {
         int lowb = a & -a ;
         if (lowb == 0) {
            lowb = b + b ;
            while (lowb & (lowb - 1))
               lowb &= lowb-1 ;
         }
         while (a + lowb > b)
            lowb >>= 1 ;
         arr[2*a+lowb].update(v) ;
         a += lowb ;
      }
   }
   int accum(int a) {
      int r = T::zero ;
      for (int b=1; b<2*sz; b *= 2) {
         r = T::sum(r, arr[2*a+b]) ;
         a &= ~b ;
      }
      return r ;
   }
   int sz ;
   vector<T> arr ;
} ;
struct bitsum {
   bitsum() : d(zero) {}
   void update(int v) { d += v ; }
   static int sum(int a, const bitsum &b) { return a+b.d ; }
   static const int zero = 0 ;
   int d ;
} ;
struct bitmax {
   bitmax() : d(zero) {}
   void update(int v) { d = v ; }
   static int sum(int a, const bitmax &b) { return max(a, b.d) ; }
   static const int zero = -1 ;
   int d ;
} ;
int main() {
   int n, m, q ;
   cin >> n >> m >> q ;
   vector<vector<int> > dat(m) ;
   BIT<bitmax> bm(n) ;
   vector<BIT<bitsum> > bsv(m) ;
   for (int i=0; i<m; i++) {
      int ts ;
      cin >> ts ;
      bsv[i].resize(ts) ;
      auto &v = dat[i] ;
      v.resize(ts) ;
      for (auto &u : v)
         cin >> u ;
   }
   vector<quad> cmds(q) ;
   vector<pair<int,int> > setvals ;
   for (int i=0; i<(int)cmds.size(); i++) {
      auto &v = cmds[i] ;
      cin >> v.cmd ;
      switch (v.cmd) {
case 1: cin >> v.i >> v.p ; v.i-- ; v.p-- ;
        bm.dorange(v.p, v.p+dat[v.i].size(), i) ;
        break ;
case 2: cin >> v.p ; v.p-- ;
        {
           int ci = bm.accum(v.p) ;
           if (ci < 0) {
              v.r = 0 ;
           } else {
              v.i = cmds[ci].i ;
              v.p -= cmds[ci].p ;
              setvals.push_back({ci, i}) ;
           }
        }
        break ;
case 3: cin >> v.i >> v.p >> v.r ; v.i-- ; v.p-- ; v.r-- ;
        break ;
      }
   }
   sort(setvals.begin(), setvals.end()) ;
   int svat = 0 ;
   for (int i=0; i<(int)cmds.size(); i++) {
      while (svat < (int)setvals.size() && setvals[svat].first == i) {
         int ci = setvals[svat++].second ;
         int di = cmds[i].i ;
         int add = cmds[ci].p ;
         cmds[ci].r = (bsv[di].accum(add) + dat[di][add]) % 256 ;
      }
      auto &v = cmds[i] ;
      if (v.cmd == 3)
         bsv[v.i].dorange(v.p, v.r+1, 1) ;
   }
   for (int i=0; i<(int)cmds.size(); i++)
      if (cmds[i].cmd == 2)
         cout << cmds[i].r << endl ;
}

L. Carry Cam Failure

“Drat!” cursed Charles. “This stupid carry bar is not working in my Engine! I just tried to calculate the square of anumber, but it’s wrong; all of the carries are lost.”

“Hmm,” mused Ada, “arithmetic without carries! I wonder if I can figure out what your original input was, based onthe result I see on the Engine.”

$a_ma_{m-1}...a_1a_0am?am−1?...a1?a0?be the digits of aa, where a_0a0? is its least significant digit. Similarly define b_nb_{n-1}...b_{1}b_0bn?bn−1?...b1?b0? be the digits of bb. The digitsof c = a otimes bc=a⊗b are given by the following equation:$

$c_k=a_0b_k oplus a_1b_{k-1}oplus ... oplus a_{k-1}b_1 oplus a_kb_0,ck?=a0?bk?⊕a1?bk−1?⊕...⊕ak−1?b1?⊕ak?b0?,$

where any

a_iai? or b_jbj? is considered zero if i > mi>m or j > nj>n. For example, 9 otimes 1 2349⊗1234 is 9 8769876, 90 otimes 1 23490⊗1234 is 98 76098760, and 99 otimes 1 23499⊗1234 is 97 53697536.Given NN, find the smallest positive integer a such that a otimes a = Na⊗a=N.

Input

The input consists of a single line with an integer

Output

Print, on a single line, the least positive number

样例输入1

样例输出1

样例输入2

123476544

样例输出2

样例输入3

样例输出3

-1

#include <iostream>
#include <string>
using namespace std ;
string s, t, r ;
int sqr(int at) {
   int sum = 0 ;
   for (int i=max(0, at-(int)r.size()); i <= at && i<(int)r.size(); i++)
      sum += r[i] * r[at-i] ;
   return s[at] == sum % 10 ;
}
int dfs(int at) {
   if (at >= (int)r.size()) {
      for (; at < (int)s.size(); at++)
         if (!sqr(at))
            return 0 ;
      return 1 ;
   }
   for (int d=0; d<10; d++) {
      r[at] = d ;
      if (!sqr(at))
         continue ;
      int t = dfs(at+1) ;
      if (t)
         return 1 ;
   }
   return 0 ;
}
int main() {
   cin >> s ;
   if (s.size() & 1) {
      t.resize(s.size()) ;
      for (auto &v : s)
         v -= ‘0‘ ;
      int rsz = (1+s.size()) >> 1 ;
      r.resize(rsz) ;
      if (dfs(0)) {
         for (auto &v : r)
            v += ‘0‘ ;
         cout << r << endl ;
         exit(0) ;
      }
   }
   cout << "-1" << endl ;
}

M. Maze Connect

Given an orthogonal maze rotated

This maze has only a single square fully enclosed. Removing any wall will connect it to the outside.

/..

../

This maze has two enclosed areas. Two walls need to be removed to connect all squares to the outside.

Input

The first line has two numbers,

Output

Output on a single line an integer indicating how many walls need to be removed so escape is possible from everysquare in the maze.

样例输入1

2 2
//

样例输出1

样例输入2

4 4
/..
..
./../

样例输出2

样例输入3

8 20
//////////../././././///
/./.././/./////.//.//..../
//.///./..//...../././/././
/.../../.././...///////////

样例输出3

#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <vector>

using namespace std;

const int MAX_SIZE = 1000;
char g[2*MAX_SIZE+2][2*MAX_SIZE+2];
int par[5 * MAX_SIZE * MAX_SIZE];
int find(int x) {
  return par[x] == x ? x : (par[x] = find(par[x]));
}
bool merge(int x, int y) {
  x = find(x);
  y = find(y);
  if(x == y) return false;
  par[x] = y;
  return true;
}
int r, c;
void solve() {
  cin >> r >> c;
  memset(g, ‘.‘, sizeof(g));
  for(int i = 0; i < r; i++) {
    string s;
    cin >> s;
    for(int j = 0; j < c; j++) {
      if(s[j] == ‘.‘) continue;
      if(s[j] == ‘/‘) {
        g[2*i+1][2*j+2] = ‘#‘;
        g[2*i+2][2*j+1] = ‘#‘;
      }
      else {
        g[2*i+1][2*j+1] = ‘#‘;
        g[2*i+2][2*j+2] = ‘#‘;
      }
    }
  }
  int maxR = 2 * r + 2;
  int maxC = 2 * c + 2;
  int comps = 0;
  for(int i = 0; i < maxR; i++) {
    for(int j = 0; j < maxC; j++) {
      if(g[i][j] == ‘#‘) continue;
      comps++;
      par[i*maxC+j] = i*maxC+j;
      if(i > 0 && g[i-1][j] == ‘.‘ && merge((i-1)*maxC + j, i*maxC + j)) comps--;
      if(j > 0 && g[i][j-1] == ‘.‘ && merge(i*maxC + j - 1, i*maxC + j)) comps--;
    }
  }
  cout << comps-1 << "
";
}

int main() {
  solve();
}

以上是关于2020.5.4-ICPC Pacific Northwest Regional Contest 2019的主要内容，如果未能解决你的问题，请参考以下文章

Pacific Atlantic Water Flow 解答

417. Pacific Atlantic Water Flow

Leetcode: Pacific Atlantic Water Flow

417 Pacific Atlantic Water Flow 太平洋大西洋水流

417. Pacific Atlantic Water Flow

2020.5.4-ICPC Pacific Northwest Regional Contest 2019

input

output

样例输入

5

样例输出

样例输入2复制

样例输出2复制

样例输入1复制

样例输出1复制

样例输入2复制

样例输出2复制

样例输入1复制

样例输出1复制

样例输入2复制

样例输出2复制

样例输入1复制

样例输出1复制

样例输入2复制

样例输出2复制

样例输入1复制

样例输出1复制

样例输入2复制

样例输出2复制

Input

Output

样例输入1复制

样例输出1复制

样例输入2复制

样例输出2复制

样例输入3复制

样例输出3复制

Input

Output

样例输入1复制

样例输出1复制

样例输入2复制

样例输出2复制

样例输入3复制

样例输出3复制

Input

Output

样例输入1复制

样例输出1复制

样例输入2复制

样例输出2复制

Input

Output

样例输入1复制

样例输出1复制

样例输入2复制

样例输出2复制

样例输入3复制

样例输出3复制

Input

Output

样例输入1复制

样例输出1复制

样例输入2复制

样例输出2复制

Input

Output

样例输入复制

样例输出复制

样例解释

Input

Output

样例输入1复制

样例输出1复制

样例输入2复制

样例输出2复制

样例输入3复制

样例输出3复制

Input

Output

样例输入1复制

样例输出1复制

样例输入2复制

样例输出2复制

样例输入3复制

样例输入2

样例输出2

样例输入1

样例输出1

样例输入2

样例输出2

样例输入1

样例输出1

样例输入2

样例输出2

样例输入1

样例输出1

样例输入2

样例输出2

样例输入1

样例输出1

样例输入2

样例输出2

样例输入1

样例输出1

样例输入2

样例输出2

样例输入3

样例输出3

样例输入1

样例输出1

样例输入2

样例输出2

样例输入3

样例输出3

样例输入1

样例输出1

样例输入2

样例输出2

样例输入1

样例输出1

样例输入2

样例输出2

样例输入3

样例输出3

样例输入1

样例输出1

样例输入2

样例输出2

样例输入

样例输出

样例输入1

样例输出1

样例输入2

样例输出2

样例输入3

样例输出3

样例输入1

样例输出1

样例输入2

样例输出2

样例输入3

样例输出3