2016-2017 ACM-ICPC Pacific Northwest Regional Contest (Div. 1) Solution

A:Alphabet

Solved.

签。

 #include<bits/stdc++.h>
 using namespace std;
 char s[];
 int f[];
 int main(){
     scanf("%s",s+);
     int n=strlen(s+);
     for(int i=;i<=n;i++)
     {
         f[i]=;
     }
     for(int i=;i<=n;i++)
     {
         for(int j=;j<i;j++)
         {
             if(s[i]>s[j]){
                 f[i]=max(f[i],f[j]+);
             }
         }
     }
     int maxn=;
     for(int i=;i<=n;i++)
     {
         maxn=max(maxn,f[i]);
     }
     cout<<-maxn<<endl;
 }

B:Buggy Robot

Solved.

题意：

给出一个地图，从'R' 走到 'E' ， 可以增加或者删除机器人的指令

求最少的修改次数，使得机器人可以到达'E'

思路：

搜索。

 #include<bits/stdc++.h>

 using namespace std;

 const int maxn =  + ;
 const int INF = 0x3f3f3f3f;

 struct node{
     int x, y;
     int step;
     node(){}
     node(int x, int y, int step): x(x), y(y), step(step){};
 };

 int n, m;
 int sx, sy, ex, ey;
 int len;
 char mp[maxn][maxn];
 char op[maxn * maxn];
 int dis[maxn][maxn][maxn * maxn];
 int dir[][] = {, , , , -, , , -};

 bool judge(int x,int y)
 {
     if(x <  || x > n || y <  || y > m || mp[x][y] == '#') return false;
     else return true;
 }

 void BFS()
 {
     queue<node>q;
     q.push(node(sx, sy, ));
     dis[sx][sy][] = ;
     while(!q.empty())
     {
         node st = q.front();
         q.pop();
         //not do
         if(st.step +  <= len)
         {
             node now = st;
             now.step++;
             if(dis[st.x][st.y][st.step] +  < dis[now.x][now.y][now.step])
             {
                 dis[now.x][now.y][now.step] = dis[st.x][st.y][st.step] + ;
                 q.push(now);
             }
         }
         //do
         if(st.step +  <= len)
         {
             node now = st;
             now.step++;
             if(op[now.step] == 'U')
             {
                 now.x--;
             }
             else if(op[now.step] == 'D')
             {
                 now.x++;
             }
             else if(op[now.step] == 'L')
             {
                 now.y--;
             }
             else if(op[now.step] == 'R')
             {
                 now.y++;
             }
             if(!judge(now.x, now.y))
             {
                 now.x = st.x;
                 now.y = st.y;
             }
             if(dis[st.x][st.y][st.step] < dis[now.x][now.y][now.step])
             {
                 dis[now.x][now.y][now.step] = dis[st.x][st.y][st.step];
                 q.push(now);
             }

         }
         //add
         node now = st;
         for(int i = ; i < ; ++i)
         {
             now.x = st.x + dir[i][];
             now.y = st.y + dir[i][];
             if(judge(now.x, now.y))
             {
                 if(dis[st.x][st.y][st.step] +  < dis[now.x][now.y][now.step])
                 {
                     dis[now.x][now.y][now.step] = dis[st.x][st.y][st.step] + ;
                     q.push(now);
                 }
             }
         }
     }
 }

 int main()
 {
     while(~scanf("%d %d", &n, &m))
     {
         for(int i = ; i <= n; ++i)
         {
             for(int j = ; j <= m; ++j)
             {
                 scanf(" %c", &mp[i][j]);
                 if(mp[i][j] == 'R'){ sx = i, sy = j; }
                 if(mp[i][j] == 'E'){ ex = i, ey = j; }
             }
         }
         scanf("%s", op + );
         len = strlen(op + );
         memset(dis, 0x3f, sizeof dis);
         BFS();
         int ans = INF;
         for(int i = ; i <= len; ++i) ans = min(ans, dis[ex][ey][i]);
         printf("%d\n", ans);
     }
     return ;
 }

C:Cameras

Solved.

签。

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

 #define N 100010
 int n, k, r, a[N];

 int main()
 {
     while (scanf("%d%d%d", &n, &k, &r) != EOF)
     {
         memset(a, , sizeof a);
         for (int i = , x; i <= k; ++i)
         {
             scanf("%d", &x);
             a[x] = ;
         }
         int res = ;
         int tot = ;
         for (int i = ; i <= r - ; ++i) tot += a[i];
         for (int i = ; i + r - <= n; ++i)
         {
             tot += a[i + r - ];
             if (tot < )
             {
                 for (int j = i + r - ; j >=  && tot < ; --j) if (!a[j])
                 {
                     a[j] = ;
                     ++tot;
                     ++res;
                 }
             }
             tot -= a[i];
         }
         printf("%d\n", res);
     }
     return ;
 }

D:Contest Strategy

Unsolved.

题意：

在一场ICPC比赛中，有一个人知道它解决每道题需要多少时间

但是必须要先读这道题，才能做

做题策略是

开场先随机读k道题，然后按做题时间放入小根堆

每次取堆顶出来做，每做一道题，就随机再读一题（如果还有题目可以读）

求$\;N!\;种读题顺序的所有罚时加起来 MOD\;\; 1e\;9 +7$

E:Enclosure

Unsolved.

F:Illumination

Solved.

题意：

有一个矩形，在某些点有灯泡，可以选择照亮当前行或者照亮当前列

每个灯泡照亮的范围相同为$r$

但是同行或者同列的照亮不能相交

求有没有一种方案使得所有灯泡都可以打开

思路：

一个点拆成两个点，表示照亮行或列

然后建边，丢进2-sat跑一跑即可

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

 #define N 2010
 int n, r, l;
 struct Graph
 {
     struct node
     {
         int to, nx;
         node () {}
         node (int to, int nx) : to(to), nx(nx) {}
     }a[N * N * ];
     int head[N], pos;
     void init()
     {
         memset(head, -, sizeof head);
         pos = ;
     }
     void add(int u, int v) { a[++pos] = node(v, head[u]); head[u] = pos; }
 }G;
 #define erp(u) for (int it = G.head[u], v = G.a[it].to; ~it; it = G.a[it].nx, v = G.a[it].to)
 int x[N], y[N];
 // 0 x 1 y

 bool vis[N];
 int S[N], top;
 bool DFS(int u)
 {
     if (vis[u ^ ]) return false;
     if (vis[u]) return true;
     vis[u] = ;
     S[top++] = u;
     erp (u) if (!DFS(v)) return false;
     return true;
 }

 bool twosat(int n)
 {
     memset(vis, , sizeof vis);
     for (int i = ; i < n; i += )
     {
         if (vis[i] || vis[i ^ ]) continue;
         top = ;
         if (!DFS(i))
         {
             while (top) vis[S[--top]] = false;
             if (!DFS(i ^ )) return false;
         }
     }
     return true;
 }

 int main()
 {
     while (scanf("%d%d%d", &n, &r, &l) != EOF)
     {
         G.init();
         for (int i = ; i < l; ++i) scanf("%d%d", x + i, y + i);
         for (int i = ; i < l; ++i) for (int j = i + ; j < l; ++j)
         {
             if (x[i] == x[j] && abs(y[i] - y[j]) <=  * r)
             {
                 G.add(i << , j <<  | );
                 G.add(j << , i <<  | );
             }
             if (y[i] == y[j] && abs(x[i] - x[j]) <=  * r)
             {
                 G.add(i <<  | , j << );
                 G.add(j <<  | , i << );
             }
         }
         puts(twosat( * l) ? "YES" : "NO");
     }
     return ;
 }

 #include<bits/stdc++.h>

 using namespace std;

 const int maxn = 2e3 + ;

 struct node{
     int x, y;
     node(){}
     node(int x,int y): x(x), y(y){}
 }arr[maxn];

 struct Edge{
     int to, nxt;
     Edge(){}
     Edge(int to, int nxt) : to(to), nxt(nxt){}
 }edge[(maxn * maxn) << ];

 int head[maxn << ], tot, vis[maxn << ];

 void Init()
 {
     tot = ;
     memset(head, -, sizeof head);
     memset(vis, , sizeof vis);
 }

 void addedge(int u, int v, int val)
 {
     int tmpu = u *  + val;
     int tmpv = v *  + val;
     edge[tot] = Edge(tmpv, head[tmpu ^ ]); head[tmpu ^ ] = tot++;
     edge[tot] = Edge(tmpu, head[tmpv ^ ]); head[tmpv ^ ] = tot++;
 }

 int n, r, l;
 int S[maxn << ], top;

 bool DFS(int u)
 {
     if(vis[u ^ ]) return false;
     if(vis[u]) return true;
     vis[u]++;
     S[top++] = u;
     for(int i = head[u]; ~i; i = edge[i].nxt)
     {
         if(!DFS(edge[i].to)) return false;
     }
     return true;
 }

 bool solve()
 {
     for(int i = ; i < (l << ); i += )
     {
         if(vis[i] ==  && vis[i ^ ] == )
         {
             top = ;
             if(!DFS(i))
             {
                 while(top) vis[S[--top]] = ;
                 if(!DFS(i ^ )) return false;
             }
         }
     }
     return true;

 }

 int main()
 {
     while(~scanf("%d %d %d", &n, &r, &l))
     {
         Init();
         for(int i = ; i < l; ++i) scanf("%d %d", &arr[i].x, &arr[i].y);
         for(int i = ; i < l; ++i)
         {
             for(int j = ; j < i; ++j)
             {
                 if(arr[i].y == arr[j].y && abs(arr[i].x - arr[j].x) <=  * r)
                 {
                     addedge(i, j, );
                 }
                 if(arr[i].x == arr[j].x && abs(arr[i].y - arr[j].y) <=  * r)
                 {
                     addedge(i, j, );
                 }
             }
         }
         puts(solve() ? "YES" : "NO");
     }
     return ;
 }

G:Maximum Islands

Unsolved.

题意：

有一张卫星图，可以看到陆地上有些地方是海洋，有些地方是陆地

陆地的连通块是岛屿，也有些地方看到的是云朵

云朵下面可以是陆地也可以是海洋

求岛屿的最大数量

H:Paint

Solved.

题意：

给出一些区间，求选出任意个数的区间，使得这些区间不相交

并且区间并最大，输出n - 区间并

思路：
类似于最长上升子序列，一个区间的左端点要接在所有右端点小于它的所有区间中的最大值即可

树状数组维护一下就没了

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

 #define ll long long
 #define N 200010
 ll n, b[N << ];
 int k, m;
 struct qnode
 {
     ll l, r;
     void scan() { scanf("%lld%lld", &l, &r); }
     bool operator < (const qnode &other) const { return r < other.r || r == other.r && l < other.l; }
 }q[N];

 void Hash()
 {
     m = ;
     for (int i = ; i <= k; ++i)
     {
         b[++m] = q[i].l;
         b[++m] = q[i].r;
     }
     sort(b + , b +  + m);
     m = unique(b + , b +  + m) - b - ;
     for (int i = ; i <= k; ++i)
     {
         q[i].l = lower_bound(b + , b +  + m, q[i].l) - b;
         q[i].r = lower_bound(b + , b +  + m, q[i].r) - b;
     }
 }

 namespace BIT
 {
     ll a[N << ];
     void update(int x, ll val)
     {
         for (; x < (N << ); x += x & -x)
             a[x] = max(a[x], val);
     }
     ll query(int x)
     {
         ll res = ;
         for (; x; x -=x & -x)
             res = max(res, a[x]);
         return res;
     }
 }

 int main()
 {
     while (scanf("%lld%d", &n, &k) != EOF)
     {
         for (int i = ; i <= k; ++i) q[i].scan(); Hash();
         sort(q + , q +  + k);
         ll res = ;
         for (int i = ; i <= k; ++i)
         {
             ll tmp = BIT::query(q[i].l - );
             tmp += b[q[i].r] - b[q[i].l] + ;
             res = max(res, tmp);
             BIT::update(q[i].r, tmp);
         }
         printf("%lld\n", n - res);
     }
     return ;
 }

I:Postman

Solved.

题意：

有n个房子，每个放在位于$x_i点$邮局在0点，每个房子有$m_i封信要送$

只有一个邮递员，每次最多携带$k_i封信，求邮递员最少的路程$

思路：

负的和正的分开做

每次都先跑最远的，如果可以携带多余的信，就给次远的，再给次次远的。

贪心做一下就没了

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

 #define ll long long
 #define N 1010
 ll res;
 int n, m, k;
 int x[N], v[N];

 struct node
 {
     int x, v;
     node () {}
     node (int x, int v) : x(x), v(v) {}
     bool operator < (const node &r) const { return x < r.x; }
 }q[N];

 void solve()
 {
     sort(q + , q +  + m);
     for (int i = m; i >= ; --i)
     {
         res += 2ll * (q[i].v / k) * q[i].x;
         int remind = q[i].v % k;
         if (remind)
         {
             remind = k - remind;
             res += 2ll * q[i].x;
             for (int j = i - ; j >= ; --j)
             {
                 if (remind >= q[j].v)
                 {
                     remind -= q[j].v;
                     q[j].v = ;
                 }
                 else
                 {
                     q[j].v -= remind;
                     break;
                 }
             }
         }
     }
 }

 int main()
 {
     while (scanf("%d%d", &n, &k) != EOF)
     {
         for (int i = ; i <= n; ++i) scanf("%d%d", x + i, v + i);
         res = ; m = ;
         for (int i = ; i <= n; ++i) if (x[i] < ) q[++m] = node(-x[i], v[i]);
         solve();
         m = ;
         for (int i = ; i <= n; ++i) if (x[i] > ) q[++m] = node(x[i], v[i]);
         solve();
         printf("%lld\n", res);
     }
     return ;
 }

j:Shopping

Solved.

题意：

有一个超市，$有n种物品，每种物品a_i元，每种物品无限个$

$q次询问，每次询问从第l_i个商品走到第r_i个商品，身上有v_i块钱，能买则买，问最后剩下多少钱$

思路：

每次购买一个物品那么手中的钱至少缩小一半

最多需要购买log种物品

再二分查找最近的小于自己的物品

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

 #define ll long long
 #define N 200010
 int n, q;
 ll a[N];

 ll dp[N][];
 int mm[N];
 void init(int n, ll b[])
 {
     mm[] = -;
     for (int i = ; i <= n; ++i)
     {
         mm[i] = ((i & (i - )) == ) ? mm[i - ] + : mm[i - ];
         dp[i][] = b[i];
     }
     for (int j = ; j <= mm[n]; ++j)
         for (int i = ; i + ( << j) -  <= n; ++i)
             dp[i][j] = min(dp[i][j - ], dp[i + ( << (j - ))][j - ]);
 }

 ll query(int l, int r)
 {
     int k = mm[r - l + ];
     return min(dp[l][k], dp[r - ( << k) + ][k]);
 }

 int main()
 {
     while (scanf("%d%d", &n, &q) != EOF)
     {
         for (int i = ; i <= n; ++i) scanf("%lld", a + i); init(n, a);
         ll v;
         for (int i = , l, r; i <= q; ++i)
         {
             scanf("%lld%d%d", &v, &l, &r);
             while (r - l >= )
             {
                 int ql = l, qr = r, tar = -;
                 while (qr - ql >= )
                 {
                     int mid = (ql + qr) >> ;
                     if (query(ql, mid) <= v)
                     {
                         qr = mid - ;
                         tar = mid;
                     }
                     else
                         ql = mid + ;
                 }
                 if (tar == -) break;
                 v %= a[tar];
                 l = tar + ;
             }
             printf("%lld\n", v);
         }
     }
     return ;
 }

K:Tournament Wins

Solved.

题意：

有$2^k个玩家，进行对局，rank小的一定能打败\;\;rank\;\;大的$

如果你$rank = r 那么求出你在一轮游戏中赢的局数的期望$

一轮游戏为每次两两对战，输的离开，赢得剩下继续对战，直到只有一个人

思路：

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

 const int maxn = ( << ) + ;
 const double EXP = exp(1.0);

 double fac[maxn];

 void Init()
 {
     fac[] = ;
     for(int i = ; i < maxn; ++i) fac[i] = fac[i - ] + log(i);
 }

 int k, r;

 int main()
 {
     Init();
     while(~scanf("%d %d", &k, &r))
     {
         double ans = ;
         int limit =  << k;
         for(int i = ; i <= k; ++i)
         {
             int m = ( << i);
             if(limit - r - m +  < ) break;
             ans += exp((fac[limit - r] - fac[limit - r -  m + ]) - (fac[limit - ] - fac[limit - m]));
         }
         printf("%.5f\n", ans);
     }
     return ;
 }

L:Windy Path

Unsolved.