CodeForces Round 619 (Rated for Div. 2) Pariticipation report

Date: Feb. 13. 2020

CodeForces Round 619 (Rated for Div. 2) Pariticipation report

Since 2019-nCov is still impacting the society.

Taking part in such a competition might be a good choice.

Generally speaking, this round is not so hard.

Let me show the problems:

---

A. Three Strings

You are given three strings a, b and c of the same length n. For the same index order, you must swap the character in c with the character in either a or b. The problem is if it is possible that after these swaps the string a becomes exactly the same as the string b.

SAMPLE INPUT

4
aaa
bbb
ccc
abc
bca
bca
aabb
bbaa
baba
imi
mii
iim

SAMPLE OUTPUT

NO
YES
YES
NO

To solve it, just compare every character in c to those in a and b for the same index. If all of the character for the same index in a or b is same to c, the answer is YES.

MY CODE

# python3
t = int(input())
for ti in range(t):
    a = input()
    b = input()
    c = input()
    f = 1
    for i in range(len(a)):
        if c[i] in (a[i],b[i]):
            pass
        else:
            print('NO')
            f = 0
            break
    if f:
        print('YES')

---

B. Motarack's Birthday

You are given an non-negetive array a with some missing elements marked as -1.Try to fill out of all missing elements with the same integer k to make the maximum absolute difference m between all adjacent elements minimized. Output the m and the k.

SAMPLE INPUT

7
5
-1 10 -1 12 -1
5
-1 40 35 -1 35
6
-1 -1 9 -1 3 -1
2
-1 -1
2
0 -1
4
1 -1 3 -1
7
1 -1 7 5 2 -1 5

SAMPLE OUTPUT

1 11
5 35
3 6
0 42
0 0
1 2
3 4

After thinking for about 20 minutes, I find the problem is asking the median of the maximum value and the minimum value.

MY CODE

t = int(input())
for ti in range(t):
    n = int(input())
    li = [int(i) for i in input().split(' ')]
    ss = 0
    cc = 0
    sep = 0
    _min = 1919810114514
    _max = 0
    for idx, i in enumerate(li):

        if i == -1:
            if idx and li[idx-1] != -1:
                _min = min(_min, li[idx-1])
                _max = max(_max, li[idx-1])

        else:
            
            if idx and li[idx-1] != -1:
                sep = max(sep, abs(li[idx-1]-i))
            elif idx and li[idx-1] == -1:
                _min = min(_min, i)
                _max = max(_max, i)
            ss += i
            cc += 1
    if cc:
        # r = round(ss/cc)
        r = (_min+_max)//2
        sep = max(sep,r - _min, _max-r)
        print(sep,r)
    else:
        print(0,0)

---

C. Ayoub's function

You are given a binary string (a string which contains only symbols "0" and "1") s. Define function f(s) is equal to the number of substring in s that contains at least one symbol of "1".

Now you know the count of "1" in every s. How will you construct s so the f(s) reach the max possible value? Output the maximum value.

SAMPLE INPUT

5
3 1
3 2
3 3
4 0
5 2

SAMPLE OUTPUT

4
5
6
0
12

Since we are finding a construction of s that makes the count of intervals contain "1" as large as possible. We can find that the f(s) is also equal to the total count of substrings in s subtract by the count of intervals contain all "0".

So we just need to make the length of every continuously "0" strings as small as possible.

MY CODE

def getarrsum(n):
    return (1+n)*n//2

t = int(input())
for ti in range(t):
    n, ctr = (int(i) for i in input().split(' '))
    if n == ctr:
        print((1+n)*n//2)
    elif ctr:
        tot = (1+n)*n//2
        c0 = n - ctr
        dvd = c0 // (1+ctr)
        rem = c0 % (1+ctr)
        cur = ctr+1 - rem
        d1 = cur * getarrsum(dvd)
        d2 = rem * getarrsum(dvd+1)
        print(tot-d1-d2)
    else:
        print(0)

---

D. Time to Run

You are given a map contain n rows and m columns like this:

Every path between adjacent cells can be visited at most once. You start at the top-left cell in the grid. If you can move exactly k times, print your route. Otherwise print NO.

SAMPLE INPUT

3 3 8

SAMPLE OUTPUT

YES
8
3 R
3 L
1 D
3 R
1 D
1 U
3 L
1 D

To visit all of the path, you can move like this:

So all we need is to count the moves and check if it can reach k.

CODE COPIED FROM STD

n,m,k= (int(i) for i in input().split(' '))

path = []
tot = 0
for i in range(n):
    path.append((m-1,'R'))
    tot += path[-1][0] * len(path[-1][1])
    if i == 0:
        path.append((m-1,'L'))
    else:
        path.append((m-1,'UDL'))
    tot += path[-1][0] * len(path[-1][1])
    if i == n-1:
        path.append((n-1,'U'))
    else:
        path.append((1,'D'))
    tot += path[-1][0] * len(path[-1][1])

if k > 4*n*m-2*n-2*m:
    print('NO')
else:
    while tot > k:
        tmp = path[-1][1]
        cur = path[-1][0] * len(tmp)
        path.pop()
        tot -= cur
        if tot >= k:
            continue
        cur = k - tot
        if cur // len(tmp) > 0:
            path.append((cur//len(tmp),tmp))

        tmp = tmp[:cur%len(tmp)]
        if len(tmp) > 0:
            path.append((1,tmp))
        tot = k
    print('YES')
    
    p2 = []

    for i in path:
        if i[0]:
            p2.append(i)
    print(len(p2))
    for i,j in p2:
        if i:
            print(i,j)

---

E. Nanosoft

You are given a picture colored by at most 4 colors: green (the symbol G), red (the symbol R), yellow (the symbol Y) and blue (the symbol B).

We define a picture logo like this:

Can you cut the largest logo from the given picture? Print the size of your logo.

SAMPLE INPUT

5 5 5
RRGGB
RRGGY
YYBBG
YYBBR
RBBRG
1 1 5 5
2 2 5 5
2 2 3 3
1 1 3 5
4 4 5 5

SAMPLE OUTPUT

16
4
4
4
0

I didn't solve this problem actually, here is the official solution:

For each cell, we will calculate the maximum size of a Nanosoft logo in which it is the bottom right cell, in the top left square.

The cell marked with x in this picture:

If we had a grid like this:

If we take the cell in the second row, second column, it can make a Nanosoft logo with size 4×4, being the bottom right cell in the top left square.

We can calculate the answer for every cell using binary search , and checking every sub-square using 2D cumulative sum.

Now we build a 2D array that contains that previous calculated answer, lets call it val[n][m].

For the previous picture val will be like this:

Now for each query we can do binary search on its answer. We check the current mid this way:

The mid will tell us the length of one of the sides divided by 2.

Like if mid = 2, the area of the square we are checking is (4⋅4=16).

Now we should check the maximum element in the 2D array val, in the 2D range: (r1+mid−1,c1+mid−1,r2−mid,c2−mid).

The current mid is correct if the maximum element in that 2D range is greater than or equal to (4⋅mid⋅mid).

We can get the maximum value in a 2D range using 2D sparse table, with build in O(n⋅m⋅logn⋅logm) and query in O(1).

total Complexity is O(n⋅m⋅logn⋅logm+q⋅logm).

But actually it can be tolerate Complexity O(n^3) for the preprocess. That means we are not forced to use binary search.

After the preprocess, each query can be handled in O(1).

STD

#include <bits/stdc++.h>
using namespace std;
#define oo 1000000010
#define mod 1000000007
const int N = 510 , LOG = 10;
char grid[N][N];
int val[N][N] , sum[N][N][4];
int st[N][N][LOG][LOG] , lg[N];
int n , q , m , r1 , c1 , r2, c2 , nr , nc;
 
string S = "RGYB";
int dr[4] = {0 , 0 , 1 , 1};
int dc[4] = {0 , 1 , 0 , 1};
 
inline bool check(int r1,int c1,int r2,int c2,int k){
    r1++,c1++,r2++,c2++;
    return ((sum[r2][c2][k] - sum[r1 - 1][c2][k] - sum[r2][c1 - 1][k] + sum[r1 - 1][c1 - 1][k]) == (r2 - r1 + 1) * (c2 - c1 + 1));
}   
 
inline bool can(int r,int c,int s){
    if(r < 0 || c < 0) return false;
    if(r + (s << 1) - 1 >= n || c + (s << 1) - 1 >= m) return false;
    for(int i =0  ;i < 4;i++){
        nr = r + dr[i] * s ;
        nc = c + dc[i] * s;
        if(!check(nr , nc , nr + s - 1 , nc + s - 1 , i))
            return false;
    }
    return true;
}
 
void build(){
    lg[1] = 0;
    for(int i = 2;i<N;i++){
        lg[i] = lg[i - 1];
        if((1 << (lg[i] + 1)) == i)
            lg[i]++;
    }
    for(int k = 1;k < LOG;k++){
        for(int i=0;i + (1 << k) <= n;i++){
            for(int j=0;j<m;j++){
                st[i][j][k][0] = max(st[i][j][k - 1][0] , st[i + (1 << (k - 1))][j][k - 1][0]);
            }
        }
    }
    for(int l = 1;l < LOG;l++){
        for(int k = 0;k < LOG;k++){
            for(int i=0;i+(1 << k) <= n;i++){
                for(int j = 0;j + (1 << l) <= m;j++){
                    st[i][j][k][l] = max(st[i][j][k][l - 1] , st[i][j + (1 << (l - 1))][k][l-1]);
                }
            }
        }
    }
}
 
int a , b;
 
inline int getmax(int r1,int c1,int r2,int c2){
    if(r2 < r1 || c2 < c1 || r1 < 0 || r2 >= n || c1 < 0 || c2 >= m) return -oo;
    a = lg[(r2 - r1) + 1];
    b = lg[(c2 - c1) + 1];
    return max(max(st[r1][c1][a][b] , st[r2 - (1 << a) + 1][c1][a][b]) , max(st[r1][c2 - (1 << b) + 1][a][b] , st[r2 - (1 << a) + 1][c2 - (1 << b) + 1][a][b]));
}
 
 
int main(){
    scanf("%d%d%d",&n,&m,&q);
    for(int i=0;i<n;i++){
        scanf(" %s",grid[i]);
        for(int j=0;j<m;j++){
            for(int k=0;k<4;k++){
                sum[i + 1][j + 1][k] = sum[i][j + 1][k] + sum[i + 1][j][k] - sum[i][j][k] + (S[k] == grid[i][j]);
            }
        }
    }
    int low , high , mid , res;
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            low = 1 , high = min(min(i + 1,n - i) , min(j + 1,m - j));
            while(high >= low){
                mid = ((low + high) >> 1);
                if(can(i - mid + 1,j - mid + 1,mid))
                    st[i][j][0][0] = mid, low = mid + 1;
                else
                    high = mid - 1;
            }
        }
    }
    build();
    while(q--){
        scanf("%d%d%d%d",&r1,&c1,&r2,&c2);
        r1--,c1--,r2--,c2--;
        low = 1 , high = (n >> 1) , res = 0;
        while(high >= low){
            mid = ((low + high) >> 1);
            if(getmax(r1 + mid - 1,c1 + mid - 1,r2 - mid , c2 - mid) >= mid)
                res = mid, low = mid + 1;
            else
                high = mid - 1;
        }
        printf("%d\n",res * res * 4);
    }
    return 0;
}

---

F. Super Jaber

You are given a n rows m columns grids colored by k (k<=40) colors. Every second you can move to adjacent cells or to a cell have the same color as you are standing on. Question is the least time consumption from cell (r1,c1) to cell (r2,c2).

SAMPLE INPUT

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

SAMPLE OUTPUT

2
0

At first I tend to use double source BFS, but unfortunately timed out.

Having discussed in ACM groups, they show me a solution to preprocess the map in time Complexity O(nmk) and memory Complexity O(nmk). Then for every query, solve it in O(k).

Preprocess the grids like this:

For every cell, calculate the nearest distance of color from 1 to k from it. So for every cell and every color, we have the nearest path saved in array dist. This can be done by multi-source BFS.

Then for every query, we can choose a best color to jump or just normally go to the endpoint without using the same color jump. So initialize the answer to Manhattan distance, literate c from 1 to k, the answer is exactly min(answer,dist[r2][c2][c],dist[r1][c1][c]).

I was worried about this solution as it seems to use same color jump only once. But I found this is not a mistake since every same color jump is done at the BFS.

I have tried to rewrite the solution in Python3, but though I used ctypes library it is too slow to solve the problem.

MY CODE

# coding:utf-8
from ctypes import *

dr = (0, 1, 0, -1)
dc = (1, 0, -1, 0)
# cost = [[0 for i in range(1000000)] for i in range(40)]
cost = (c_int8 * (1000000) * 40)()
class que():
    def __init__(self):

        self.mem = (c_int32 * 1000000)()
        self.l = 0
        self.r = 0
        self.M = 1000000
    def push(self,ar):

        if self.r >= self.M:
            self.r -= self.M

        self.mem[self.r] = ar
        self.r += 1
    def pop(self):
        if self.l >= self.M:
            self.l -= self.M
        self.l += 1
        return self.mem[self.l-1]
    def anything(self):
        return self.r != self.l
    def clear(self):
        self.l = 0
        self.r = 0

q = que()

n, m, k = (int(i) for i in input().split(' '))
grid = []  
cells = [[] for i in range(k)]




def bfs(col):
    q.clear()

    for kk in cells[col]:
        cost[col][kk] = -1
        q.push(kk)
    done = (c_bool * k)()

    while q.anything():

        now = q.pop()
        nx = now // m
        ny = now - nx * m

        now_col = grid[now]
        if not done[now_col]:
            done[now_col] = 1
            for kk in cells[now_col]:
                if 0 == cost[col][kk]:
                    cost[col][kk] = max(0,cost[col][now]) + 1
                    q.push(kk)


        for i in range(4):
            cx,cy = nx+dr[i], ny+dc[i]
            cur = cx*m+cy
            if cx >= 0 and cx < n and \
               cy >= 0 and cy < m and \
               0 == cost[col][cur]:
                cost[col][cur] = max(0,cost[col][now]) + 1
                q.push(cur)




for i in range(n):
    tmp = [int(j)-1 for j in input().split(' ')]
    grid += tmp
    for jd, j in enumerate(tmp):
        cells[j].append(i*m+jd)



for co in range(k):
    bfs(co)

t = int(input())
for ti in range(t):
    x,y,X,Y = (int(i)-1 for i in input().split(' '))
    ans = abs(x-X) + abs(y-Y)
    for i in range(k):
        if cost[i][x*m+y] == -1:
            cost[i][x*m+y] = 0
        if cost[i][X*m+Y] == -1:
            cost[i][X*m+Y] = 0
        ans = min(ans, 1 + cost[i][x*m+y] + cost[i][X*m+Y])
    print(ans)

STD

#include <bits/stdc++.h>
using namespace std;
#define oo 1000000000
#define mod 998244353
const int N = 1010 , K = 45; 
int n , m , k , r1 , r2 , c1 , c2 , grid[N][N] , ans = 0;
 
int cost[K][N][N];
bool done[K];
 
queue < pair<int,int> > q;
 
int dr[4] = {0 , 1 , 0 , -1};
int dc[4] = {1 , 0 ,-1 ,  0};
 
vector < pair<int,int> > cells[K];
 
void BFS(int col){
    for(int i = 0; i < (int)cells[col].size();i++){
        cost[col][cells[col][i].first][cells[col][i].second] = 0;
        q.push(make_pair(cells[col][i].first,cells[col][i].second));
    }
    for(int i = 1;i <= k;i++) done[i] = false;
    int r , c , nr , nc;
    while(!q.empty()){
        r = q.front().first;
        c = q.front().second;
        q.pop();
        if(!done[grid[r][c]]){
            done[grid[r][c]] = true;
            for(int i = 0 ; i < (int)cells[grid[r][c]].size() ;i++){
                nr = cells[grid[r][c]][i].first;
                nc = cells[grid[r][c]][i].second;
                if(cost[col][nr][nc] == -1){
                    cost[col][nr][nc] = cost[col][r][c] + 1;
                    q.push(make_pair(nr , nc));
                }
            }
        }
        for(int i = 0 ;i < 4;i++){
            nr = r + dr[i];
            nc = c + dc[i];
            if(nr >= 0 && nr < n && nc >= 0 && nc < m && cost[col][nr][nc] == -1){
                cost[col][nr][nc] = cost[col][r][c] + 1;
                q.push(make_pair(nr , nc));
            }
        }
    }
}
 
 
int main(){
    scanf("%d%d%d",&n,&m,&k);
    for(int i = 0 ;i < n;i++){
        for(int j = 0 ;j < m;j++){
            scanf("%d",&grid[i][j]);
            cells[grid[i][j]].push_back(make_pair(i , j));
        }
    }
    memset(cost,  -1, sizeof(cost));
    for(int i = 1;i <= k;i++)
        BFS(i);
    int q;
    scanf("%d",&q);
    while(q--){
        scanf("%d%d%d%d",&r1,&c1,&r2,&c2);
        r1--,c1--,r2--,c2--;
        ans = abs(r1 - r2) + abs(c1 - c2);
        for(int i = 1;i <= k;i++)
            ans = min(ans , 1 + cost[i][r1][c1] + cost[i][r2][c2]);
        printf("%d\n",ans);
    }
    return 0;
}

嘛，为了应付英语日记写成了英语