#include<bits/stdc++.

h> /*aggressive_cows*/ using namespace std; bool A; return 0; } #include<iostream>//burst true// #define endl ”\n” using
Comperator(int x,int a[],int n,int k){int currentCows=1;int leftmost=0;for(int namespace std; int f(int i, int j, int v[], int dp[][502], int n){ if(i>j) return 0; int
i=1;i<n;++i){if(a[i]-a[leftmost]>=x){leftmost=i;++currentCows;if(currentCows==k)return ans = -1e9; if(dp[i][j]!=-1) return dp[i][j]; for(int ind=i; ind<=j; ind++){ int
1;}}return 0;} int main(){int t;cin»t;for(int i=0;i<t;++i){int n,k;cin»n»k;int c; if((i-1==0)&&(j+1==n-1)) c=v[ind]+f(i,ind-1,v,dp,n)+f(ind+1,j,v,dp,n);
a[100000];for(int j=0;j<n;++j){cin»a[j];}sort(a,a+n);int l=0,r=a[n-1]- else c=v[i-1]*v[j+1]+f(i,ind-1,v,dp,n)+f(ind+1,j,v,dp,n); ans=(ans>c)?ans:c;
a[0]+1;while(r-l>0){int m=(l+r+1)/2;if(Comperator(m,a,n,k)==true){l=m;}else } return dp[i][j]=ans; } int main(){ int n; cin»n; int v[502]; v[0]=1; for(int
r=m-1;}cout«l«’\n’;}} #include <iostream>/*broken_number*/ using names- i=1;i<=n;i++) cin»v[i]; v[n+1]=1; int dp[502][502]; for(int i=0;i<=n+1;i++)
pace std; #define ll long long ll n, m, o, k; ll a[20]; ll b[20]; char operators[] for(int j=0;j<=n+1;j++) dp[i][j]=-1; cout«f(1,n,v,dp,n+2)«endl; return 0; }
= {’+’, ’-’, ’*’, ’/’}; bool valid(string s) { if (s.size() == 0) return false; for #include<bits/stdc++.h>/*camel*/ using namespace std; int n; int a[20];
(int i = 0; i < s.size(); i++) { if (s[i] == ’+’ || s[i] == ’-’ || s[i] == ’*’ || s[i] bool visA[20], visB[20]; int ans; void back(bool isLeft, int cost){ int cnt=0;
== ’/’) { if (s[s.size() - 1] == ’=’) return true; else return false; } } return for(int i=0;i<n;i++){ if(visB[i]) cnt++; } if(cnt==n){ ans=min(ans,cost);
true; } ll calculate(string &s) { ll result = 0, current = 0; char operation = return; } if(isLeft){ for(int i=0;i<n;i++){ for(int j=i+1;j<n;j++){
’.’; for (ll i = 0; i < s.size(); i++) { if (s[i] >= ’0’ && s[i] <= ’9’) { current if(visA[i]&&visA[j]){ visA[i]=false; visA[j]=false; visB[i]=true; visB[j]=true;
= current * 10 + (s[i] - ’0’); } else { if (operation == ’+’) result += current; back(false,cost+max(a[i],a[j])); visA[i]=true; visA[j]=true; visB[i]=false;
else if (operation == ’-’) result -= current; else if (operation == ’*’) result *= visB[j]=false; } } } } else{ for(int i=0;i<n;i++){ if(visB[i]){ visB[i]=false;
current; else if (operation == ’/’ && current != 0 && result % current == visA[i]=true; back(true,cost+a[i]); visB[i]=true; visA[i]=false; } } } } void
0) result /= current; else if (operation == ’.’) result = current; current = 0; solve(){ cin»n; for(int i=0;i<n;i++) cin»a[i]; memset(visA,true,sizeof(visA));
operation = s[i]; } } if (s[s.size() - 1] != ’=’) result = current; return result; } memset(visB,false,sizeof(visB)); ans=INT_MAX; back(true,0); cout«ans«endl;
ll minOperations; void findSolution(string &s, ll opCount, bool operatorUsed) } int main(){ int t; cin»t; while(t--) solve(); return 0; } #include<bits/stdc++.h>
{ if (opCount > o || s.size() > minOperations || (valid(s) && calculate(s) > /*car_fule*/using namespace std; int n,a[20],ans; void back(int car,int dis,int
1000)) return; if (operatorUsed) { if (opCount < o && s[s.size() - 1] >= ’0’ && pos,int type,int fuel){ if(dis>ans) return; if(car==n){ ans=min(ans,dis);
s[s.size() - 1] <= ’9’) { string temp = s + ’=’; ll ans = calculate(temp); if (ans return; } if(pos==0){ back(car,dis+1,pos+1,1,2); return; } if(pos==n+1){
== k) minOperations = (minOperations < (opCount + 1)) ? minOperations back(car,dis+1,pos-1,2,2); return; } int nextPos,refillCost,refillLoc; if(type==1){
: (opCount + 1); } } else if (s.size()) { ll ans = calculate(s); if (ans == k) nextPos=1; refillCost=pos; refillLoc=0; } else{ nextPos=-1; refillCost=n-
minOperations = (minOperations < opCount) ? minOperations : opCount; } pos+1; refillLoc=n+1; } if(type==a[pos]){ if(fuel>0){ int x=a[pos]; a[pos]=0;
for (ll i = 0; i < n; i++) { string temp = s + char(a[i] + ’0’); findSolution(temp, back(car+1,dis+1,pos+nextPos,type,fuel-1); back(car+1,dis+refillCost,refillLoc,type,fuel);
opCount + 1, operatorUsed); } if (s.size() && s[s.size() - 1] >= ’0’ && s[s.size() a[pos]=x; } back(car,dis+1,pos+nextPos,type,fuel); } else{ back(car,dis+1,pos+nextPos,type,fuel);
- 1] <= ’9’ && opCount < o - 1) { for (ll i = 0; i < m; i++) { string temp } } void solve(){ cin»n; for(int i=1;i<=n;i++) cin»a[i]; ans=INT_MAX;
= s + operators[b[i] - 1]; findSolution(temp, opCount + 1, true); } } } void back(0,0,0,0,0); cout«ans-1«endl; } int main(){ int t; cin»t; while(t--) solve();
solve() { cin » n » m » o; for (ll i = 0; i < n; i++) cin » a[i]; for (ll i = 0; i return 0; } #include <iostream> /*chess*/#include <stdio.h>#include
< m; i++) cin » b[i]; cin » k; minOperations = 1e18; string expression = ””; <cstring>using namespace std; struct data { int x; int y; int level; }; data
findSolution(expression, 0, false); cout « minOperations « ”\n”; } int main() queue[10000]; int front,rear; int mv[8][2]={{-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-
{ ios_base::sync_with_stdio(0); cin.tie(0); ll testCases; cin » testCases; while 2},{-1,-2},{-2,-1}}; void push(data d) { queue[rear++]=d; } data pop() {
(testCases--) solve(); return 0; } #include <iostream> /*burst_ballons*/ using return queue[front++]; } bool empty() { return front==rear; } int main()
namespace std; int maxCoins(int* nums, int size) { int** dp = new int*[size]; { int T; cin»T; for(int t=1;t<=T;t++){ int n,m,r1,c1,r2,c2; cin»n»m; int
for (int i = 0; i < size; i++) { dp[i] = new int[size]; for (int j = 0; j < size; a[101][101]; memset(a,0,sizeof(a)); cin»r1»c1»r2»c2; data d,d1,d2; front=0;
j++) { dp[i][j] = 0; } } for (int len = 1; len <= size; len++) { for (int i = rear=0; d.x=r1; d.y=c1; d.level=0; push(d); a[d.x][d.y]=2; int tmx,tmy,tml;
0; i <= size - len; i++) { int j = len + i - 1; for (int k = i; k <= j; k++) int steps=0; bool f=false; while(!empty()){ if(f)break; d1=pop(); for(int
{ int leftValue = 1; int rightValue = 1; if (i != 0) leftValue = nums[i - 1]; if k=0;k<8;k++){ tmx=d1.x+mv[k][0]; tmy=d1.y+mv[k][1]; tml=d1.level+1;
(j != size - 1) rightValue = nums[j + 1]; int before = 0; int after = 0; if (i if(tmx>=1&&tmx<=n&&tmy>=1&&tmy<=m&&a[tmx][tmy]==0){ if(tmx==r2&&tmy==c2){
!= k) before = dp[i][k - 1]; if (j != k) after = dp[k + 1][j]; dp[i][j] = (dp[i][j] steps=tml; f=true; break; } d2.x=tmx; d2.y=tmy; d2.level=tml; push(d2);
> leftValue * nums[k] * rightValue + before + after) ? dp[i][j] : leftValue a[d2.x][d2.y]=2; }}} if(!f){ steps=-1; } cout«steps«endl; } return 0; } #in-
* nums[k] * rightValue + before + after; } } } int result = dp[0][size - 1]; clude<iostream>//convex_false// #include<vector> #include<algorithm>
for (int i = 0; i < size; i++) { delete[] dp[i]; } delete[] dp; return result; } using namespace std; struct Point{ int x,y; }; int orientation(Point p,Point
int main() { int siz; cin » siz; int* A = new int[siz]; for (int i = 0; i < siz; q,Point r){ int val=(q.y-p.y)*(r.x-q.x)-(q.x-p.x)*(r.y-q.y); if(val==0)return 0;
i++) { cin » A[i]; } int ans = maxCoins(A, siz); cout « ans « endl; delete[] return (val>0)?1:2; } bool cmp(Point a,Point b){ return (a.x==b.x)?(a.y<b.y):(a.x<b.y);

1 2

} bool myFunc(Point a,Point b){ return (a.x==b.x&&a.y==b.y); } void con- 0; } #include<iostream>//detect_cycle_directed.cpp// #include<queue>
vexHull(Point* points,int n){ if(n<3){ cout«”-1”; return; } vector<Point> using namespace std; #define endl ”\n” #define int long long int adj[15][15];
hull; int l=0; for(int i=1;i<n;i++) if(points[i].x<points[l].x) l=i; int int n,m; void solve(){ cin»n»m; int edge[m][2]; for(int i=0;i<m;i++){ int u,v;
p=l,q; do{ hull.push_back(points[p]); q=(p+1)%n; for(int i=0;i<n;i++) cin»u»v; adj[u][v]=1; edge[i][0]=u; edge[i][1]=v; } int sum=1e9; int path[15]; int
if(orientation(points[p],points[i],points[q])==2) q=i; p=q; }while(p!=l); path_size=0; for(int i=0;i<m;i++){ int u=edge[i][0],v=edge[i][1]; adj[u][v]=0;
sort(hull.begin(),hull.end(),cmp); auto ip=unique(hull.begin(),hull.end(),myFunc); int d[n+1]; for(int j=1;j<=n;j++) d[j]=1e9; d[v]=v; int q[100],front=0,back=0;
hull.resize(distance(hull.begin(),ip)); if(hull.size()<3){ cout«”-1”; return; }else{ q[back++]=v; int par[15]; par[v]=v; while(front<back){ int x=q[front++];
for(int i=0;i<hull.size();i++){ cout«hull[i].x«” ”«hull[i].y; if(i!=hull.size()- for(int y=1;y<=n;y++){ if(adj[x][y]&&d[x]+y<d[y]){ d[y]=d[x]+y; par[y]=x;
1) cout«”, ”; } } } int main(){ int t,n; cin»t; while(t--){ cin»n; Point* q[back++]=y; } } } if(d[u]<sum){ sum=d[u]; path_size=0; while(par[u]!=u){
points=new Point[n]; for(int i=0;i<n;i++){ cin»points[i].x»points[i].y; path[path_size++]=u; u=par[u]; } path[path_size++]=u; } adj[u][v]=1; }
} convexHull(points,n); cout«”\n”; delete[] points; } return 0; } #in- for(int i=0;i<path_size-1;i++){ for(int j=i+1;j<path_size;j++){ if(path[i]>path[j]){
clude<iostream>//convex// #include<algorithm> using namespace std; struct int temp=path[i]; path[i]=path[j]; path[j]=temp; } } } for(int i=0;i<path_size;i++)
Point{ int x,y; }; int getRotationAngle(Point a,Point b,Point c){ return((b.x- cout«path[i]«’ ’; cout«endl; } int32_t main(){ solve(); return 0; } #in-
a.x)*(c.y-a.y))-((b.y-a.y)*(c.x-a.x)); } void outerTrees(Point* trees,int n){ clude<iostream>//detect_cycle_undirected// using namespace std; int nodes,
if(n<=3){ for(int i=0;i<n;++i){ if(i!=n-1){ cout«trees[i].x«” ”«trees[i].y«”, ”; edges; int adj[100][100] = {0}; bool findCycle(int node, bool visited[], int parent,
}else{ cout«trees[i].x«” ”«trees[i].y; } } return; } Point upperHull[n]; int upper- int& prev){ visited[node] = true; for(int j = 0; j < nodes; j++){ if(adj[node][j]
Size=0; upperHull[upperSize++]=trees[0]; upperHull[upperSize++]=trees[1]; == 1 && !visited[j]){ if(findCycle(j, visited, node, prev)){ if(node == prev){
for(int i=2;i<n;++i){ while(upperSize>=2&&getRotationAngle(upperHull[upperSize- cout«node«” ”; prev = -1; } else if(prev != -1) cout«node«” ”; return true;
2],upperHull[upperSize-1],trees[i])>0){ upperSize--; } upperHull[upperSize++]=trees[i]; } } else if(adj[node][j] == 1 && visited[j] && parent != j){ cout«node«” ”;
} Point lowerHull[n]; int lowerSize=0; lowerHull[lowerSize++]=trees[n-1]; prev = j; return true; } } return false; } int main(){ cin»nodes»edges; int
lowerHull[lowerSize++]=trees[n-2]; for(int i=n-3;i>=0;--i){ while(lowerSize>=2&&getRotationAngle(lowerHull[lowerSize- u,v; while(edges--){ cin»u»v; adj[u][v] = 1; adj[v][u] = 1; } bool visited[nodes]
2],lowerHull[lowerSize-1],trees[i])>0){ lowerSize--; } lowerHull[lowerSize++]=trees[i]; = {false}; int parent = -1, prev = -1; if(!findCycle(0, visited, parent, prev))
} Point result[2*n]; int resultSize=0; for(int i=0;i<upperSize;++i){ re- cout«”-1”; return 0; } #include <iostream>//doctor_probability// using
sult[resultSize++]=upperHull[i]; } for(int i=0;i<lowerSize;++i){ bool dupli- namespace std; void docProb(double **graph, int nodes, int time, int curNode,
cate=false; for(int j=0;j<resultSize;++j){ if(lowerHull[i].x==result[j].x&&lowerHull[i].y==result[j].y){ double p, double *answer) { if (time <= 0) { answer[curNode] += p; return;
duplicate=true; break; } } if(!duplicate){ result[resultSize++]=lowerHull[i]; } for (int i = 0; i < nodes; i++) { if (graph[curNode][i] != 0) { double
} } for(int i=0;i<resultSize;++i){ if(i!=resultSize-1){ cout«result[i].x«” ”«re- originalProb = p; p *= graph[curNode][i]; docProb(graph, nodes, time - 10,
sult[i].y«”, ”; }else{ cout«result[i].x«” ”«result[i].y; } } } int main(){ int t,n; i, p, answer); p = originalProb; } } } int main() { int t; cin » t; while (t--)
cin»t; while(t--){ cin»n; Point* trees=new Point[n]; for(int i=0;i<n;++i){ { int nodes, edges, time; cin » nodes » edges » time; double **arr = new
cin»trees[i].x»trees[i].y; } outerTrees(trees,n); cout«”\n”; delete[] trees; double*[nodes]; for (int i = 0; i < nodes; i++) { arr[i] = new double[nodes];
} return 0; } #include<iostream> /*crow_pot*/ #include<algorithm> for (int j = 0; j < nodes; j++) { arr[i][j] = 0; } } int from, to; double prob;
using namespace std; int n, k; void merger(int *overflow_numbers, int for (int i = 0; i < edges; i++) { cin » from » to » prob; arr[from - 1][to
l, int m, int r){ int i,j,k; int n1=m-l+1; int n2=r-m; int L[n1], R[n2]; - 1] = prob; } double *answer = new double[nodes](); docProb(arr, nodes,
for(int i=0; i<n1; i++){ L[i]=overflow_numbers[l+i]; } for(int j=0; j<n2; time, 0, 1.0, answer); double finalProb = 0.0; int finalDivision = 0; for (int
j++){ R[j]=overflow_numbers[m+1+j]; } i=0; j=0; k=l; while(i<n1 i = 0; i < nodes; i++) { if (answer[i] > finalProb) { finalProb = answer[i];
&& j<n2){ if(L[i]<=R[j]){ overflow_numbers[k]=L[i]; i++; }else{ over- finalDivision = i; } } cout « finalDivision + 1 « ” ” « fixed « finalProb «
flow_numbers[k]=R[j]; j++; } k++; } while(i<n1){ overflow_numbers[k]=L[i]; ”\n”; for (int i = 0; i < nodes; i++) { delete[] arr[i]; } delete[] arr; delete[]
k++; i++; } while(j<n2){ overflow_numbers[k]=R[j]; k++; j++; } } answer; } return 0; } #include<iostream> //endoscope//using namespace
void merge_sort(int *overflow, int l, int r){ if(l<r){ int m=l+(r-l)/2; std; int row,col,X,Y,L; int map[1000][1000],visited[1000][1000]; struct node{
merge_sort(overflow, l, m); merge_sort(overflow, m+1, r); merger(overflow, int x,y,l; }; node q[1000000]; int front,back; void init(){ front=0,back=0; }
l, m, r); } } int minCrowPotStoneSecond(int *overflow_numbers){ void push(node temp){ q[back++]=temp; } node pop(){ return q[front++];
int total_stones=0; for(int i=n-1; i>0; i--){ overflow_numbers[i] = } bool empty(){ return front == back; } bool valid(int x,int y){ return
max(0,overflow_numbers[i]-overflow_numbers[i-1]); } for(int i=0; i<k; (x>=0 && x<row && y>=0 && y<col); } bool left(int x,int y){ return
i++){ total_stones+=(overflow_numbers[i]*(n-i)); } return total_stones; } (map[x][y]==1 || map[x][y]==3 || map[x][y]==6 || map[x][y]==7); } bool
int main(){ cin » n; int *arr = new int[n + 1]; for(int i=0;i<n;i++){ cin»arr[i]; right(int x,int y){ return (map[x][y]==1 || map[x][y]==3 || map[x][y]==4 ||
} cin » k; merge_sort(arr, 0, n-1); cout « minCrowPotStoneSecond(arr); return map[x][y]==5); } bool up(int x,int y){ return (map[x][y]==1 || map[x][y]==2 ||

3 4
map[x][y]==4 || map[x][y]==7); } bool down(int x,int y){ return (map[x][y]==1 -1) { color[j] = 1 - color[i]; flag = flag & isBiPartite(j, color); } else if(color[i]
|| map[x][y]==2 || map[x][y]==6 || map[x][y]==5); } int solve(int x,int y,int == color[j]) return false; } } return flag; } int main() { cin » n; int color[n];
l){ int ans = 0; push({x,y,l}); visited[x][y]=1; while(!empty()){ node cur for(int i=0;i<n;i++) { color[i] = -1; for(int j=0;j<n;j++) { cin » arr[i][j]; } }
= pop(); int x = cur.x; int y = cur.y; int l = cur.l; if(l==0) continue; for(int i=0;i<n;i++) { if(color[i]==-1) { color[i] = 0; if(!isBiPartite(i,color))
ans++; if(valid(x,y-1) && left(x,y) && right(x,y-1) && visited[x][y-1]==0){ { cout « ”-1” « endl; return 0; } } } for(int i=0;i<n;i++) { if(color[i] == 0)
push({x,y-1,l-1}); visited[x][y-1]=1; } if(valid(x,y+1) && right(x,y) && cout « i « ” ”; } return 0; } #include <iostream>/*jewels_maze*/#include
left(x,y+1) && visited[x][y+1]==0){ push({x,y+1,l-1}); visited[x][y+1]=1; } <climits>#define MAX 21 using namespace std; int n, ans; bool isValid(int
if(valid(x-1,y) && up(x,y) && down(x-1,y) && visited[x-1][y]==0){ push({x- i, int j){ return (i>=0 && i<n && j>=0 && j<n); } void printMatrix(int
1,y,l-1}); visited[x-1][y]=1; } if(valid(x+1,y) && down(x,y) && up(x+1,y) **arr){ for(int i=0; i<n; i++){ for(int j=0; j<n; j++) cout « arr[i][j] « ” ”; cout
&& visited[x+1][y]==0){ push({x+1,y,l-1}); visited[x+1][y]=1; } } return « endl; } } int dirX[] = {1,0,-1,0}; int dirY[] = {0,1,0,-1}; void jewelMaze(int
ans; } int main(){ int t; cin»t; while(t--){ cin»row»col»X»Y»L; init(); for(int **maze, int x, int y, int value, int **visited, int **path){ if(x == n-1 && y ==
i=0;i<row;i++){ for(int j=0;j<col;j++){ cin»map[i][j]; visited[i][j]=0; } } n-1){ if(value >= ans){ ans = value; for(int i=0; i<n; i++){ for(int j=0; j<n;
if(map[X][Y]>0){ cout«solve(X,Y,L)«endl; } else cout«0«endl; } } #include j++) if(visited[i][j]){ path[i][j] = 3; } else{ path[i][j] = maze[i][j]; } } } return;
<iostream> //fishermen// #include <climits> using namespace std; int g[3], } for(int i=0; i<4; i++){ int newX = x + dirX[i]; int newY = y + dirY[i];
f[3]; int vis[100]; int n; int left(int i) { if(i >= 0){ int d = 0; for(int j = i; j if(isValid(newX, newY)){ if(visited[newX][newY] == 0 && maze[newX][newY]
>= 0; j--){ d++; if(!vis[j]) return d; } } return INT_MAX; } int right(int i) { == 0){ visited[newX][newY] = 1; jewelMaze(maze, newX, newY, value,
if(i < n) { int d = 0; for(int j = i; j < n; j++){ d++; if(!vis[j]) return d; } } visited, path); visited[newX][newY] = 0; } if(visited[newX][newY] == 0 &&
return INT_MAX; } int dist(int gate){ int pos = g[gate]-1; int d = 0; for(int maze[newX][newY] == 2){ visited[newX][newY] = 1; jewelMaze(maze, newX,
i = 0; i < f[gate]; i++){ if(!vis[pos]){ d += 1; vis[pos] = true; } else { int newY, value+1, visited, path); visited[newX][newY] = 0; } } } } int main(){
l = left(pos-1); int r = right(pos+1); if(l < r) { d += l+1; if(pos - l >= 0) int t; cin » t; while(t--){ cin » n; int **maze = new int * [n + 1]; for(int i=0;
vis[pos-l] = true; } else { d += r+1; if(r + pos < n) vis[r+pos] = true; } } i<n; i++){ maze[i] = new int[n + 1]; } int **visited = new int * [n + 1];
} return d; } int calc(int x[]){ int d = 0; for(int i = 0; i < n; i++) vis[i] = for(int i=0; i<n; i++){ visited[i] = new int[n + 1]; } int **path = new int *
false; for(int i = 0; i < 3; i++) d += dist(x[i]); return d; } int main(){ cin » [n + 1]; for(int i=0; i<n; i++){ path[i] = new int[n + 1]; } for(int i=0; i<n;
n; for(int i = 0; i < 3; i++) cin » g[i]; for(int i = 0; i < 3; i++) cin » f[i]; int i++){ for(int j=0; j<n; j++){ cin » maze[i][j]; visited[i][j] = 0; path[i][j] = 0;
perm[6][3] = {{0, 1, 2}, {0, 2, 1}, {1, 0, 2}, {1, 2, 0}, {2, 0, 1}, {2, 1, 0}}; int } } ans = INT_MIN; int sX = 0, sY = 0; visited[sX][sY] = 1; if(maze[sX][sY]
min_d = INT_MAX; for(int i = 0; i < 6; i++){ int d = calc(perm[i]); if(d < == 2) jewelMaze(maze, sX, sY, 1, visited, path); else jewelMaze(maze, sX,
min_d) min_d = d; } cout « min_d « endl; return 0; } #include <iostream> sY, 0, visited, path); printMatrix(path); cout « ans « endl; } return 0; }
//frog_jump// #include <climits> using namespace std; #define QS 1000005 #include <iostream>//kim.cpp// #include <cmath> #include <climits>
struct Point { int x, y; }; int n, sX, sY, tX, tY; int mat[105][105], dis[105][105], using namespace std; const int MAX_N = 12; int cust[MAX_N][2], dp[1 «
vis[105][105]; Point queue[QS]; int front = 0, rear = 0; int dirX[] = {1, 0, -1, MAX_N][MAX_N]; int solve(int n, int ox, int oy, int hx, int hy) { for (int
0}; int dirY[] = {0, 1, 0, -1}; bool isValid(int i, int j) { return (i >= 0 && i mask = 0; mask < (1 « n); ++mask) for (int i = 0; i < n; ++i) dp[mask][i] =
< n && j >= 0 && j < n); } void calculateFrogJump() { queue[rear].x = sX; INT_MAX; for (int i = 0; i < n; ++i) dp[1 « i][i] = abs(ox - cust[i][0]) + abs(oy
queue[rear].y = sY; rear = (rear + 1) % QS; vis[sX][sY] = 1; dis[sX][sY] = - cust[i][1]); for (int mask = 1; mask < (1 « n); ++mask) for (int i = 0; i < n;
0; while (front != rear) { int p = queue[front].x; int q = queue[front].y; front ++i) { if (!(mask & (1 « i))) continue; for (int j = 0; j < n; ++j) { if (!(mask
= (front + 1) % QS; for (int i = 0; i < 4; i++) { int newX = p + dirX[i]; & (1 « j))) continue; dp[mask][i] = min(dp[mask][i], dp[mask ^ (1 « i)][j] +
int newY = q + dirY[i]; if (isValid(newX, newY) && mat[newX][newY] == abs(cust[i][0] - cust[j][0]) + abs(cust[i][1] - cust[j][1])); } } int ans = INT_MAX,
1 && vis[newX][newY] == 0) { if (i == 1 || i == 3) { dis[newX][newY] = mask = (1 « n) - 1; for (int i = 0; i < n; ++i) ans = min(ans, dp[mask][i] +
dis[p][q]; } else if (i == 0 || i == 2) { dis[newX][newY] = 1 + dis[p][q]; } abs(hx - cust[i][0]) + abs(hy - cust[i][1])); return ans; } int main() { int t; cin » t;
vis[newX][newY] = 1; queue[rear].x = newX; queue[rear].y = newY; rear = int q = 1; while (t--) { int n, ox, oy, hx, hy; cin » n » ox » oy » hx » hy; for (int
(rear + 1) % QS; } } } if (vis[tX][tY]) { cout « dis[tX][tY] « endl; } else { cout i = 0; i < n; ++i) cin » cust[i][0] » cust[i][1]; cout « ”# ” « q « ” ” « solve(n, ox,
« -1 « endl; } } int main() { cin » n; for (int i = 0; i < n; i++) { for (int j = oy, hx, hy) « endl; q++; } return 0; } #include <cmath>//kth_level// #in-
0; j < n; j++) { cin » mat[i][j]; vis[i][j] = 0; dis[i][j] = INT_MAX; } } cin » clude <cstring> #include <cstdio> #include <vector> #include <iostream>
sX » sY » tX » tY; if (sX == tX && sY == tY) { cout « 0 « endl; return 0; #include <algorithm> using namespace std; int tonum(string str) { int num=0;
} calculateFrogJump(); return 0; } #include<iostream> //isbiparite// using for(int i=0;i<str.size();i++) num=num*10+(int(str[i])-48); return num; } int
namespace std; int n; int arr[100][100]={0}; bool isBiPartite(int i,int color[]) main() { int k; cin»k; string s; cin»s; int level=-1, sum=0, n=s.size(); for(int
{ bool flag = true; for(int j=0;j<n;j++) { if(arr[i][j] == 1) { if(color[j] == i=0;i<n;i++) { if(s[i] == ’(’) level++; else if(s[i] == ’)’) level--; else if(level ==

5 6

k) { string tmp; while(i<n && s[i] != ’(’ && s[i] != ’)’) { tmp.push_back(s[i]); cin»n; vector<vector<int»arr; for(int i=0;i<n;i++) { vector<int>temp; for(int
i++; } i--; sum+=tonum(tmp); } } cout«sum«endl; return 0; } #include j=0;j<n;j++) { int x; cin»x; temp.push_back(x); } arr.push_back(temp);
<iostream>//laughing_gas// #include <stdio.h> #include <string.h> using } int ini_mask=1; int total_mask=(1«n)-1; cout«solve(n, arr, 0, ini_mask,
namespace std; typedef struct { int x; int y; int level; } data; int mv[4][2] = total_mask)«endl; } return 0; } #include <iostream> //mens_restroom//
{{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; int main() { int T; cin » T; for (int t = 1; using namespace std; int main() { int t; cin » t; while (t--) { int n, k; cin » n »
t <= T; t++) { int n, m, r, c; cin » n » m; int a[m+1][n+1]; memset(a, 0, k; int v[100] = {0}; while (k--) { int mxLen = 0, lastIdx, cnt = 0; for (int i = 0;
sizeof(int) * m * n); for (int i = 1; i <= m; i++) { for (int j = 1; j <= n; i < n; i++) { if (v[i] == 0) cnt++; else cnt = 0; if (cnt >= mxLen) { mxLen
j++) { cin » a[i][j]; } } cin » r » c; data queue[10000]; int front = 0, rear = 0; = cnt; lastIdx = i; } } int s = lastIdx - mxLen + 1; int md = (lastIdx + s) /
data d, d1, d2; int tmx, tmy, tml; d.x = c; d.y = r; d.level = 1; queue[rear++] 2; v[md] = 1; } for (int i = 0; i < n; i++) cout « v[i]; cout « endl; } return 0;
= d; a[d.x][d.y] = 2; while (front != rear) { d1 = queue[front++]; for (int k } #include<iostream>//min_node_sum_cycle// #include<bits/stdc++.h>
= 0; k < 4; k++) { tmx = d1.x + mv[k][0]; tmy = d1.y + mv[k][1]; tml = using namespace std; vector<int> ans; int sum=0; void solve(int i, int start, vec-
d1.level + 1; if (a[tmx][tmy] == 1) { d2.x = tmx; d2.y = tmy; d2.level = tor<vector<int» &graph, vector<int> &pathVisited, vector<int> &curCycle,
tml; a[d2.x][d2.y] = 2; queue[rear++] = d2; } } } cout « ”Case #” « t « endl; int curSum){ pathVisited[i] = 1; curSum += i; curCycle.push_back(i); for(int
cout « tml - 1 « endl; } return 0; } #include <iostream>//laughing_gas// neigh: graph[i]){ if(!pathVisited[neigh]){ solve(neigh, start, graph, pathVisited,
#include <stdio.h> #include <string.h> using namespace std; typedef struct curCycle, curSum); } if(pathVisited[neigh] && neigh==start){ if(sum==0 ||
{ int x; int y; int level; } data; int mv[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; sum > curSum){ sum = curSum; ans = curCycle; } } } pathVisited[i] = 0;
int main() { int T; cin » T; for (int t = 1; t <= T; t++) { int n, m, r, c; cin curCycle.pop_back(); } vector<int> cycle(vector<vector<int» &graph){ int
» n » m; int a[m+1][n+1]; memset(a, 0, sizeof(int) * m * n); for (int i = 1; n=graph.size(); vector<int> pathVisited(n); vector<int> curCycle; for(int
i <= m; i++) { for (int j = 1; j <= n; j++) { cin » a[i][j]; } } cin » r » c; i=1; i<n; i++){ solve(i, i, graph, pathVisited, curCycle, 0); } if(ans.empty())
data queue[10000]; int front = 0, rear = 0; data d, d1, d2; int tmx, tmy, tml; ans.push_back(0); sort(ans.begin(), ans.end()); return ans; } int main(){ int
d.x = c; d.y = r; d.level = 1; queue[rear++] = d; a[d.x][d.y] = 2; while (front n, m; cin»n»m; vector<vector<int» graph(n+1); for(int i=0; i<m; i++){
!= rear) { d1 = queue[front++]; for (int k = 0; k < 4; k++) { tmx = d1.x int a, b; cin»a»b; graph[a].push_back(b); } vector<int> ans = cycle(graph);
+ mv[k][0]; tmy = d1.y + mv[k][1]; tml = d1.level + 1; if (a[tmx][tmy] == 1) for(size_t i=0; i<ans.size(); i++){ cout«ans[i]«” ”; } cout«endl; return 0; }
{ d2.x = tmx; d2.y = tmy; d2.level = tml; a[d2.x][d2.y] = 2; queue[rear++] #include <iostream>//missing_positive_number.cpp// #include <cmath>
= d2; } } } cout « ”Case #” « t « endl; cout « tml - 1 « endl; } return 0; } using namespace std; int main() { int t; cin » t; while (t--) { int n; cin » n; bool
#include <iostream> //lee_true// #include <climits> using namespace std; allNeg = true; int arr[n]; for (int i = 0; i < n; i++) { cin » arr[i]; if (arr[i] > 0)
const int MAX_N = 12; const int INF = 1e9; int cost[MAX_N][MAX_N]; int allNeg = false; } if (allNeg) { cout « ”1\n”; break; } int i = 0, j = n - 1; while (i
dp[1 « MAX_N][MAX_N]; int minCost(int n) { if (n == 1) return 0; for (int < j) { if (arr[i] < 0) i++; else if (arr[j] >= 0) j--; else { int temp = arr[i]; arr[i] =
mask = 0; mask < (1 « (n - 1)); ++mask) { for (int i = 0; i < (n - 1); ++i) { arr[j]; arr[j] = temp; i++; j--; } } for (int k = 0; k < n; k++) { if (arr[k] >= 0) {
dp[mask][i] = INF; } } for (int i = 0; i < (n - 1); ++i) { dp[1 « i][i] = (cost[0][i i = k; break; } } int maxPos = n - i; for (int x = i; x < n; x++) { if (abs(arr[x])
+ 1] == 0 ? INF : cost[0][i + 1]); } for (int mask = 1; mask < (1 « (n - 1)); > maxPos) continue; arr[i + abs(arr[x]) - 1] = -abs(arr[i + abs(arr[x]) - 1]);
++mask) { for (int i = 0; i < (n - 1); ++i) { if (!(mask & (1 « i))) continue; if (arr[i + abs(arr[x]) - 1] == 0) arr[i + abs(arr[x]) - 1] = -10000001; } bool
for (int j = 0; j < (n - 1); ++j) { if (i == j || !(mask & (1 « j))) continue; int ansFound = false; for (int z = i; z < n; z++) { if (arr[z] >= 0) { cout « z -
cur = dp[mask ^ (1 « i)][j] + (cost[j + 1][i + 1] == 0 ? INF : cost[j + 1][i + i + 1 « ”\n”; ansFound = true; break; } } if (!ansFound) cout « maxPos + 1
1]); dp[mask][i] = min(dp[mask][i], cur); } } } int ans = INF; int mask = (1 « ”\n”; } return 0; } #include<iostream> //monotonic// #include<cmath>
« (n - 1)) - 1; for (int i = 0; i < (n - 1); ++i) { int c = (cost[i + 1][0] == 0 using namespace std; long long func(long long a, long long b, long long c, long
? INF : cost[i + 1][0]); ans = min(ans, dp[mask][i] + c); } return ans; } int long n){ long long res = a * n; res += b * n * floor(log2(n)); res += c * (n *
main() { int t; cin » t; while (t--) { int n; cin » n; for (int i = 0; i < n; ++i) n * n); return res; } int solve(long long a, long long b, long long c, long long
{ for (int j = 0; j < n; ++j) { cin » cost[i][j]; } } cout « minCost(n) « endl; k){ long long low = 1; long long high = (c == 0) ? 1ll * (1e15) : 1ll * (1e6);
} return 0; } #include <cmath> //lee.cpp// #include <cstdio> #include long long ans = 0; while(low <= high){ long long mid = low + (high - low)/2;
<vector> #include <climits> #include <iostream> #include <algorithm> long long val = func(a, b, c, mid); if(val == k){ ans = mid; break; } if(val <
using namespace std; int solve(int n, vector<vector<int»&arr, int index, int k) low = mid+1; else high = mid-1; } return ans; } int main(){ long long a, b,
ini_mask, int total_mask) { if(ini_mask==total_mask) { return arr[index][0]; c, k; cin»a»b»c»k; cout«solve(a, b, c, k); return 0; } #include <iostream>//
} int ans=INT_MAX; for(int i=0;i<n;i++) { if((ini_mask & (1«i))==0) { int oil_mines// #include <climits> using namespace std; int companies, mines,
y=(ini_mask | (1«i)); int temp = arr[index][i]+solve(n, arr, i, y , total_mask); ANS; int MIN(int x, int y){ return (x>=y) ? y : x; } int MAX(int x, int
ans=min(ans, temp); } } return ans; } int main() { int t; cin»t; while(t--) { int n; y){ return (x>=y) ? x : y; } void calculateOilMines(int i, int *oilMines, bool

7 8
*visited, int minV, int maxV, int sum, int nodes, int &ANS){ if(visited[i]){ int - 1] == 1 || region[row][col - 1] == 3)) { visited[row][col - 1] = val + 1;
newMin = MIN(sum, minV); int newMax = MAX(sum, maxV); if(nodes == ++rear; Q[rear].row = row; Q[rear].col = col - 1; } if ((col + 1) <= N &&
companies - 1){ ANS = min(ANS, newMax - newMin); } return; } visited[i] visited[row][col + 1] == 0 && (region[row][col + 1] == 1 || region[row][col + 1]
= 1; int j = (i + 1) % mines; calculateOilMines(j, oilMines, visited, minV, == 3)) { visited[row][col + 1] = val + 1; ++rear; Q[rear].row = row; Q[rear].col
maxV, sum + oilMines[i], nodes, ANS); int newMin = MIN(sum, minV); int = col + 1; } while (front < rear) { ++front; discover(Q[front].row, Q[front].col,
newMax = MAX(sum, maxV); calculateOilMines(j, oilMines, visited, newMin, visited[Q[front].row][Q[front].col]); } } int main() { int T, test_case; cin » T;
newMax, oilMines[i], nodes + 1, ANS); visited[i] = 0; return; } int main() { int for (test_case = 0; test_case < T; test_case++) { int i, j, k, x, y, temp = 0;
t; cin » t; while(t--){ cin » companies » mines; int *oilMines = new int[mines Answer = 9999; cin » N » C; for (i = 0; i < C; i++) { cin » x » y; location[i][0]
+ 1]; bool *visited = new bool[mines + 1]; for(int i=0; i<mines; i++){ cin = x; location[i][1] = y; } for (i = 1; i <= N; i++) for (j = 1; j <= N; j++) cin
» oilMines[i]; visited[i] = 0; } ANS = INT_MAX; for(int i=0; i<mines; i++) » region[i][j]; for (k = 0; k < C; k++) region[location[k][0]][location[k][1]] = 3;
calculateOilMines(i, oilMines, visited, INT_MAX, INT_MIN, 0, 0, ANS); cout init(); Answer = 9999; for (i = 1; i <= N; i++) { for (j = 1; j <= N; j++) {
« ANS « endl; } return 0; } #include <iostream>// omnious_number// using init(); temp = 0; if (region[i][j] == 1) { visited[i][j] = 1; discover(i, j, 1); for
namespace std; int numberOminous(int a, int b, int k, int *delNos, int n){ (k = 0; k < C; k++) if (temp < visited[location[k][0]][location[k][1]]) temp =
int count = 0; for(int i = a; i <= b; i++){ int temp = i; int digitArray[10] visited[location[k][0]][location[k][1]]; if (Answer > temp) Answer = temp; } } }
= {0}; while(temp){ digitArray[temp%10]++; temp /= 10; } int rougeK = cout « Answer - 1 « endl; } return 0; } #include <iostream>//rock_climbing//
0; for(int i=0; i<n; i++){ rougeK += digitArray[delNos[i]]; } if(rougeK < int hillMap[100][100]; int vis[100][100]; struct QueueNode { int row, col; };
k){ count++; } } return count; } int main() { int a, b, k; cin » a » b » QueueNode q[10000]; int isPossible(int n, int m, int mid) { int front = 0, rear =
k; int n; cin » n; int *delNos = new int[n]; for(int i=0; i<n; i++){ cin » 0, i, j, k; for (i = 0; i < n; i++) for (j = 0; j < m; j++) vis[i][j] = 0; q[rear++]
delNos[i]; } cout « numberOminous(a, b, k, delNos, n) « ”\n”; return 0; } = {n - 1, 0}; vis[n - 1][0] = 1; while (front < rear) { i = q[front].row; j =
#include <bits/stdc++.h> //physical_energy //using namespace std; int q[front].col; front++; if (hillMap[i][j] == 3) return 1; for (k = i - mid; k <= i +
dp[5000][5000][10]; int solve(int h, int d, int cost[], int time[], int n) { if (n == mid; k++) { if (k < 0 || k >= n || !hillMap[k][j] || vis[k][j]) continue; vis[k][j] =
0 && d == 0) return 0; if (n == 0) return 1000; if (dp[h][d][n] != -1) return 1; q[rear++] = {k, j}; } if (j != 0 && hillMap[i][j - 1] && !vis[i][j - 1]) { vis[i][j -
dp[h][d][n]; if (cost[n - 1] <= h) { int op1 = solve(h - cost[n - 1], d - 1, cost, 1] = 1; q[rear++] = {i, j - 1}; } if (j != m - 1 && hillMap[i][j + 1] && !vis[i][j +
time, n) + time[n - 1]; int op2 = solve(h, d, cost, time, n - 1); return dp[h][d][n] 1]) { vis[i][j + 1] = 1; q[rear++] = {i, j + 1}; } } return 0; } int findMinDiff(int
= min(op1, op2); } else return dp[h][d][n] = solve(h, d, cost, time, n - 1); } int n, int m) { int left = 0, right = n - 1, mid; while (left <= right) { mid = (left
main() { int h, d; cin » h » d; int cost[] = {4, 5, 2, 3, 6}; int time[] = {200, + right) / 2; if (isPossible(n, m, mid)) right = mid - 1; else left = mid + 1;
210, 230, 235, 215}; memset(dp, -1, sizeof(dp)); cout « solve(h, d, cost, time, } return left; } int main() { int n, m, i, j; std::cin » n » m; for (i = 0; i < n;
5); return 0; } #include <iostream>//pillars// using namespace std; void i++) for (j = 0; j < m; j++) std::cin » hillMap[i][j]; std::cout « findMinDiff(n,
solve(int a[], int vis[], int p1, int p2, int n, int &ans) { if(p1 == p2 && p1 > m) « std::endl; return 0; } #include <iostream> //sinkhole//using namespace
ans) ans = p1; for(int i=0; i<n; ++i) { if(vis[i] == 0) { vis[i] = 1; solve(a, std; #define INT_MAX 100000 int best_xb, best_yb, best_xt, best_yt;
vis, p1 + a[i], p2, n, ans); solve(a, vis, p1, p2 + a[i], n, ans); vis[i] = 0; } } } int best_area = 0, best_sinkholes = INT_MAX; int findMinimumSum(int
int main() { int n; cin»n; int a[n]; for(int i=0; i<n; ++i) cin»a[i]; int vis[n] = dp[][102], int N, int M, int k) { int minSum = INT_MAX; for (int i = 0; i <=
{0}; int ans = -1; solve(a, vis, 0, 0, n, ans); cout«ans; } #include <iostream> N - k; i++) { for (int j = 0; j <= M - k; j++) { int sum = dp[i + k][j + k] - dp[i
//research_team// #define MAX 22 using namespace std; int Answer = 9999; + k][j] - dp[i][j + k] + dp[i][j]; if (sum < minSum) { minSum = sum; if (minSum
int region[MAX][MAX]; int visited[MAX][MAX]; int N, C; int location[5][2]; int <= 1) { best_xb = i + 1; best_yb = j + 1; best_xt = i + k; best_yt = j +
rear = -1; int front = -1; struct queue { int row; int col; } Q[10000]; void init() k; } } } } return minSum; } void updateBestResult(int area, int sinkholes, int
{ int m, n; rear = -1; front = -1; for (m = 0; m < MAX; m++) for (n = 0; n < xb, int yb, int xt, int yt) { if (area > best_area || (area == best_area &&
MAX; n++) visited[m][n] = 0; for (m = 0; m < 10000; m++) Q[m].row = 0, sinkholes < best_sinkholes)) { best_area = area; best_sinkholes = sinkholes;
Q[m].col = 0; } void discover(int row, int col, int val) { int k, cnt = 0; for (k = 0; best_xb = xb; best_yb = yb; best_xt = xt; best_yt = yt; } } int main() {
k < C; k++) if (visited[location[k][0]][location[k][1]] > 0) cnt++; if (cnt >= C) ios_base::sync_with_stdio(0); cin.tie(0); int T; cin » T; for (int t = 1; t <= T;
return; if ((row - 1) >= 1 && visited[row - 1][col] == 0 && (region[row - 1][col] t++) { int N, M; cin » N » M; int A[102][102] = {0}; int K; cin » K; for (int i
== 1 || region[row - 1][col] == 3)) { visited[row - 1][col] = val + 1; ++rear; = 0; i < K; i++) { int x, y; cin » x » y; A[x - 1][y - 1] = 1; } int dp[102][102]
Q[rear].row = row - 1; Q[rear].col = col; } if ((row + 1) <= N && visited[row = {0}; for (int i = 1; i <= N; i++) { for (int j = 1; j <= M; j++) { dp[i][j]
+ 1][col] == 0 && (region[row + 1][col] == 1 || region[row + 1][col] == 3)) = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + A[i - 1][j - 1]; } } best_area = 0;
{ visited[row + 1][col] = val + 1; ++rear; Q[rear].row = row + 1; Q[rear].col best_sinkholes = INT_MAX; int left = 1, right = (N < M ? N : M); while
= col; } if ((col - 1) >= 1 && visited[row][col - 1] == 0 && (region[row][col (left <= right) { int mid = (left + right) / 2; int ones = findMinimumSum(dp,

9 10

N, M, mid); if (ones <= 1) { updateBestResult(mid * mid, ones, best_xb, - ’a’] += temp; } for(int i=0; i<26; i++) { if(hash[i] != 0) { char temp = i
best_yb, best_xt, best_yt); left = mid + 1; } else { right = mid - 1; } } cout + ’a’; cout « temp « ” ” « hash[i] « ” ”; } } } int main() { char s[100]; cin »
« best_xb « ” ” « best_yb « ” ” « best_xt « ” ” « best_yt « endl; } return s; mergeAplha(s); return 0; } #include <iostream>//toggle_binary_matrix//
0; } #include <iostream> //spaceship_bomb// #include <climits> using #define fast ios_base::sync_with_stdio(0); cin.tie(0); using namespace std; int
namespace std; int ans; void getMaxCoins(int** b, int isSafe, int r, int c, bool n, m; int v[20][20]; int finalAns; void flip(int col, int v[20][20]) { for (int i =
bomb, int coins, int rows) { if (r < 0 || c >= 5 || c < 0) { ans = max(ans, coins); 0; i < n; i++) { v[i][col] = !v[i][col]; } } void back(int col, int k, int v[20][20])
return; } if (b[r][c] == 1 || b[r][c] == 0) { int new_coins = coins; if (b[r][c] { if (k == 0) { int ans = 0; for (int i = 0; i < n; i++) { int cnt = 0; for
== 1) new_coins++; if (bomb) isSafe--; getMaxCoins(b, isSafe, r - 1, c, bomb, (int j = 0; j < m; j++) { if (v[i][j] == 1) cnt++; } if (cnt == m) ans++; }
new_coins, rows); getMaxCoins(b, isSafe, r - 1, c + 1, bomb, new_coins, rows); finalAns = (ans > finalAns) ? ans : finalAns; return; } if (col >= m) return;
getMaxCoins(b, isSafe, r - 1, c - 1, bomb, new_coins, rows); } else if (b[r][c] back(col + 1, k, v); int cpy[20][20]; for (int i = 0; i < n; i++) for (int j =
== 2) { if (bomb && isSafe <= 0) { ans = max(ans, coins); return; } else if 0; j < m; j++) cpy[i][j] = v[i][j]; for (int p = 1; p <= k; p++) { flip(col,
(bomb && isSafe > 0) { isSafe--; getMaxCoins(b, isSafe, r - 1, c, bomb, coins, cpy); back(col + 1, k - p, cpy); } } void solve() { int k; cin » n » m » k;
rows); getMaxCoins(b, isSafe, r - 1, c + 1, bomb, coins, rows); getMaxCoins(b, for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin » v[i][j]; } }
isSafe, r - 1, c - 1, bomb, coins, rows); } else { bomb = true; isSafe = 4; finalAns = 0; back(0, k, v); cout « finalAns « endl; } int main() { fast; int t;
getMaxCoins(b, isSafe, r - 1, c, bomb, coins, rows); getMaxCoins(b, isSafe, r - cin » t; while(t--) solve(); return 0; } #include <iostream> //tall tax// using
1, c + 1, bomb, coins, rows); getMaxCoins(b, isSafe, r - 1, c - 1, bomb, coins, namespace std; int n; int ans; struct tolls{ int men; int cost; }toll[100]; void
rows); } } } int main() { int t; cin » t; int q = 1; while (t--) { ans = INT_MIN; solve(int cur_pos, int bt3, int bt2, int bt1, int cost){ if(cost>ans) return; int
int r; cin » r; int** b = new int*[r]; for (int i = 0; i < r; i++) b[i] = new int[5]; total_men = bt1 + bt2 + bt3; if(cur_pos==n){ ans=min(ans,cost); return; }
for (int i = 0; i < r; i++) for (int j = 0; j < 5; j++) cin » b[i][j]; int isSafe = solve(cur_pos + 1, bt3, bt2, bt1, cost + toll[cur_pos].cost); solve(cur_pos + 1,
0; getMaxCoins(b, isSafe, r - 1, 1, false, 0, r); getMaxCoins(b, isSafe, r - 1, 2, bt3 + toll[cur_pos].men, bt2, bt1, cost + 2*toll[cur_pos].cost); if(total_men
false, 0, r); getMaxCoins(b, isSafe, r - 1, 3, false, 0, r); cout « ”#” « q « ” ” « > toll[cur_pos].men){ if(toll[cur_pos].men > bt1 + bt2) bt3 = total_men
ans « endl; q++; for (int i = 0; i < r; i++) delete[] b[i]; delete[] b; } return 0; - toll[cur_pos].men; if(toll[cur_pos].men > bt1) bt2 = toll[cur_pos].men
} #include<iostream>//star_align// using namespace std; void setLeft(int n, >=bt1 + bt2 ? 0 : bt2 - toll[cur_pos].men + bt1; solve(cur_pos + 1, 0, bt3,
int m, char** mat, int** left) { for(int i = 0; i < n; i++) { int prevStar = -1; bt2, cost); } } int main() { int t; cin»t; while(t--){ cin»n; for(int i=0; i<n;
for(int j = 0; j < m; j++) { if(mat[i][j] == ’S’) prevStar = j; if(prevStar != i++) cin»toll[i].men»toll[i].cost; ans=99999; solve(0,0,0,0,0); cout«ans«endl; }
-1) left[i][j] = (j - prevStar); } for(int j = 0; j < m; j++) { if(mat[i][j] == ’S’) return 0; } #include <iostream>//wormhole.cpp// #include <cmath> using
break; left[i][j] = (j + (m - prevStar)); } } } void setRight(int n, int m, char** namespace std; struct Pos { long long x1, x2, y1, y2, t; }; Pos p, a[25]; long
mat, int** right) { for(int i = 0; i < n; i++) { int prevStar = -1; for(int j = m long n, visited[25], res; void robot(long long time, pair<long long, long long>
- 1; j >= 0; j--) { if(mat[i][j] == ’S’) prevStar = j; if(prevStar != -1) right[i][j] v) { res = min(res, time + abs(v.first - p.x2) + abs(v.second - p.y2)); for (long
= (prevStar - j); } for(int j = m - 1; j >= 0; j--) { if(mat[i][j] == ’S’) break; long i = 0; i < n; i++) { if (visited[i]) continue; long long dist = abs(a[i].x1
right[i][j] = (prevStar + (m - j)); } } } int solve(int n, int m, char** mat) { - v.first) + abs(a[i].y1 - v.second) + a[i].t; visited[i]++; robot(time + dist,
int** left = new int*[n]; int** right = new int*[n]; for(int i = 0; i < n; i++) { {a[i].x2, a[i].y2}); dist = abs(a[i].x2 - v.first) + abs(a[i].y2 - v.second) + a[i].t;
left[i] = new int[m]; right[i] = new int[m]; for(int j = 0; j < m; j++) { left[i][j] robot(time + dist, {a[i].x1, a[i].y1}); visited[i]--; } } int main() { long long t;
= -1; right[i][j] = -1; } } setLeft(n, m, mat, left); setRight(n, m, mat, right); int cin » t; for (long long j = 1; j <= t; j++) { cin » n; cin » p.x1 » p.y1 » p.x2 »
minShift = 2147483647; for(int j = 0; j < m; j++) { int shift = 0; for(int i = 0; p.y2; for (long long i = 0; i < n; i++) { cin » a[i].x1 » a[i].y1 » a[i].x2 » a[i].y2 »
i < n; i++) { shift += (left[i][j] < right[i][j] ? left[i][j] : right[i][j]); } if(shift < a[i].t; } res = abs(p.x1 - p.x2) + abs(p.y1 - p.y2); robot(0, {p.x1, p.y1}); cout
minShift) minShift = shift; } for(int i = 0; i < n; i++) { delete[] left[i]; delete[] « ”#” « j « ” : ” « res « endl; } return 0; }
right[i]; } delete[] left; delete[] right; return minShift; } int main() { int n, m;
cin » n » m; char** mat = new char*[n]; for(int i = 0; i < n; i++) { mat[i]
= new char[m]; for(int j = 0; j < m; j++) cin » mat[i][j]; } cout « solve(n,
m, mat); return 0; } #include <iostream> //string_compression// using
namespace std; int lengthOfString(char *str) { int len = 0, i = 0; while(str[i] !=
’\0’) { len++; i++; } return len; } void mergeAplha(char *str) { int lenString
= lengthOfString(str); int hash[26] = {0}; for(int i=0; i<lenString; i++) {
char letter = str[i]; i++; int temp = 0; while(i<lenString && str[i] >= ’0’
&& str[i] <= ’9’) { temp = (temp * 10) + (str[i]-’0’); i++; } i--; hash[letter

11 12