2018 ACM-ICPC World Finals

我重写行不？

Comma Sprinkler

签到题，类似于BFS用两个队列维护每种单词前/后是否有逗号向前/后扩展，需要注意如果有句号挡着是不能扩展过去的，不过样例有。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
map<string, vector<int>> M;
bool pre[maxn], suc[maxn];
bool st[maxn], ed[maxn];
queue<string> QP, QS;
set<string> SP, SS;
string str[maxn];

int main() {
    string s;
    getline(cin, s);
    int l = s.length(), p = 1;
    st[p] = true;
    for(int i = 0; i < l; ++i) {
        if(s[i] == ',') {
            suc[p] = pre[p + 1] = true;
            ++p, ++i;
        }
        else if(s[i] == '.') {
            ed[p] = st[p + 1] = true;
            ++p, ++i;
        }
        else if(s[i] == ' ') ++p;
        else str[p].push_back(s[i]);
    }
    for(int i = 1; i < p; ++i) M[str[i]].push_back(i);
    for(int i = 1; i < p; ++i) {
        if(pre[i] && SP.find(str[i]) == SP.end()) SP.insert(str[i]), QP.push(str[i]);
        if(suc[i] && SS.find(str[i]) == SS.end()) SS.insert(str[i]), QS.push(str[i]);
    }
    while(!QP.empty() || !QS.empty()) {
        while(!QP.empty()) {
            string cur = QP.front(); QP.pop();
            vector<int>& pos = M[cur];
            for(int i = 0; i < pos.size(); ++i) {
                int x = pos[i];
                if(!st[x]) pre[x] = true;
                if(x - 1 > 0 && !ed[x - 1] && SS.find(str[x - 1]) == SS.end()) suc[x - 1] = true, SS.insert(str[x - 1]), QS.push(str[x - 1]);
            }
        }
        while(!QS.empty()) {
            string cur = QS.front(); QS.pop();
            vector<int>& pos = M[cur];
            for(int i = 0; i < pos.size(); ++i) {
                int x = pos[i];
                if(!ed[x]) suc[x] = true;
                if(x + 1 < p && !st[x + 1] && SP.find(str[x + 1]) == SP.end()) pre[x + 1] = true, SP.insert(str[x + 1]), QP.push(str[x + 1]);
            }
        }
    }
    for(int i = 1; i < p; ++i) {
        cout << str[i];
        if(ed[i]) cout << '.';
        else if(suc[i]) cout << ',';
        if(i < p - 1) cout << ' ';
        else cout << endl;
    }
    return 0;
}

Wireless is the New Fiber

题意是构造一棵树使得树上度与原图度不相等的节点尽量少。

考虑一个贪心，按度从小到大排序后，对于每个度大于1的点，在上面挂叶子直到度为1，那么这个连通块也看成一个叶子。

如果某个时刻叶子不够了，那么就舍弃度最大的点，把它当做叶子挂上去。

最后如果还有叶子没用完，若剩两个叶子正好拼成一棵树，否则舍弃一个叶子作为根把别的挂上去。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10;
typedef pair<int, int> pii;
int deg[maxn], id[maxn];
vector<pii> ans2;
vector<int> one;

bool cmp(int i, int j) {
    return deg[i] < deg[j];
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    int ans1 = n;
    for(int i = 1; i <= m; ++i) {
        int u, v;
        scanf("%d %d", &u, &v);
        ++u, ++v;
        deg[u] += 1, deg[v] += 1;
    }
    for(int i = 1; i <= n; ++i) id[i] = i;
    sort(id + 1, id + 1 + n, cmp);
    int st = 1, ed = n;
    while(st <= n && deg[id[st]] == 1) {
        one.push_back(id[st]);
        ++st;
    }
    for(int i = st; i <= ed; ++i) {
        int x = id[i];
        while(deg[x] > 1 && !one.empty()) {
            int y = one.back();
            one.pop_back();
            deg[x]--, deg[y]--;
            ans1--;
            ans2.emplace_back(pii(x, y));
        }
        while(deg[x] > 1 && ed > i) {
            int y = id[ed];
            deg[x]--, deg[y]--;
            ans2.emplace_back(pii(x, y));
            ed--;
        }
        if(deg[x] == 1) one.push_back(x);
    }
    if(one.size() > 1) {
        for(int i = 1; i < one.size(); ++i)
            ans2.emplace_back(pii(one[0], one[i]));
        ans1 -= one.size() - 1;
        if(one.size() == 2) ans1--;
    }
    printf("%d
%d %d
", ans1, n, int(ans2.size()));
    for(int i = 0; i < ans2.size(); ++i) printf("%d %d
", ans2[i].first - 1, ans2[i].second - 1);
    return 0;
}

Go with the Flow

暴力枚举长度，然后算每个空格的最长链，时限卡的有点紧。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int pre[maxn], cur[maxn];
vector<int> v;

int main() {
    int n, wid = -1, ans = 0, sum = 0, M = 0;
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) {
        char s[111];
        scanf("%s", s);
        int l = strlen(s);
        v.push_back(l);
        M = max(M, l);
        sum += l;
    }
    for(int W = M; W <= sum + n - 1; ++W) {
        int tmp = 0;
        vector<int> P, C;
        int pos = 0, fir = 1, ok = 0;
        for(int i = 0; i < v.size(); ++i) {
            if(!fir && pos + 1 + v[i] > W) {
                for(int j = 0; j < P.size(); ++j) pre[P[j]] = 0;
                for(int j = 0; j < C.size(); ++j) pre[C[j]] = cur[C[j]], cur[C[j]] = 0;
                P = C, C.clear();
                fir = 1;
                pos = 0;
            }
            if(fir) {
                pos += v[i];
                fir = 0;
            }
            else {
                pos += 1;
                int r = 1;
                if(pos > 1) r = max(r, pre[pos - 1] + 1);
                r = max(r, pre[pos] + 1);
                if(pos < W) r = max(r, pre[pos + 1] + 1);
                cur[pos] = r, C.push_back(pos);
                pos += v[i];
                tmp = max(tmp, r);
            }
            if(pos == W) ok = 1;
        }
        if(ok && tmp > ans) ans = tmp, wid = W;
        for(int j = 0; j < P.size(); ++j) pre[P[j]] = 0;
        for(int j = 0; j < C.size(); ++j) cur[C[j]] = 0;
    }
    printf("%d %d
", wid, ans);
    return 0;
}

Catch the Plane

将线路按出发时间排序，倒着dp。

对于每条线路(a, b, s, t, p)，记a点在严格大于s时刻的最优值为ta，b点在严格大于t的最优值为tb。

每个时刻的决策有两种，若选择乘坐，则以p的概率转移到tb，1 - p概率继承ta；若不乘坐则直接继承ta。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, int> pr;
const int maxn = 1e6 + 10;
map<ll, double> :: iterator ita, itb;
map<ll, double> f[maxn];
int a[maxn], b[maxn];
ll s[maxn], t[maxn];
double p[maxn];
vector<pr> v;

int main() {
    ll k;
    int m, n;
    scanf("%d %d %lld", &m, &n, &k);
    for(int i = 1; i <= m; ++i) {
        scanf("%d %d %lld %lld %lf", a + i, b + i, s + i, t + i, p + i);
        v.emplace_back(pr(s[i], i));
    }
    sort(v.begin(), v.end());
    f[1][k + 1] = 1;
    for(int i = int(v.size()) - 1; i >= 0; --i) {
        int e = v[i].second, ai = a[e], bi = b[e];
        ll si = v[i].first, ti = t[e];
        double pi = p[e];
        ita = f[ai].upper_bound(si);
        itb = f[bi].upper_bound(ti);
        double ta = 0, tb = 0;
        if(ita != f[ai].end()) ta = (*ita).second;
        if(itb != f[bi].end()) tb = (*itb).second;
        f[ai][si] = max(f[ai][si], max(ta, pi * tb + (1 - pi) * ta));
    }
    printf("%.8f
", (*f[0].begin()).second);
    return 0;
}

Single Cut of Failure

注意到取两条对角线是一定可以切到所有线段的，因此答案最大为2，只需考虑1的情况。

将线段转变为环上的区间，相当于找两个端点切开所有区间。

枚举其中一个位置，另一个双指针单调移动。

最后将答案投回矩形上的位置。

注意不能重点，不能取角点。

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
typedef pair<int, int> pii;
bool vis[maxn];
vector<pii> v;
int n, w, h;

inline int cal(int x, int y) {
    if(x == 0) return y;
    if(y == h) return h + x;
    if(x == w) return 2 * h + w - y;
    return 2 * (h + w) - x;
}

inline void get(double t, double& x, double& y) {
    if(t <= h) x = 0, y = t;
    else if(t <= h + w) x = t - h, y = h;
    else if(t <= 2 * h + w) x = w, y = 2 * h + w - t;
    else x = 2 * (h + w) - t, y = 0;
}

int main() {
    scanf("%d %d %d", &n, &w, &h);
    for(int i = 0; i < n; ++i) {
        int X1, Y1, X2, Y2;
        scanf("%d %d %d %d", &X1, &Y1, &X2, &Y2);
        v.push_back(pii(cal(X1, Y1), i));
        v.push_back(pii(cal(X2, Y2), i));
    }
    sort(v.begin(), v.end());
    int sz = int(v.size()), p = 0, cnt = 0, one = 0;
    for(int i = 0; i < sz; ++i) {
        if(p == i) vis[v[i].second] = true, ++p, ++cnt;
        while(!vis[v[p].second]) vis[v[p].second] = true, p = (p + 1) % sz, ++cnt;
        if(cnt == n) {
            double ax1, ay1, ax2, ay2;
            get(v[i].first - 0.5, ax1, ay1);
            get(v[p].first - 0.5, ax2, ay2);
            printf("1
%.8f %.8f %.8f %.8f
", ax1, ay1, ax2, ay2);
            one = 1; break;
        }
        vis[v[i].second] = false, --cnt;
    }
    if(!one) printf("2
0.5 0 %.8f %.8f
0 %.8f %.8f %.8f
", w - 0.5, 1.0 * h, h - 0.5, 1.0 * w, 0.5);
    return 0;
}

Triangles

考虑统计每个▽，将图上下翻转后再做一次即为全部三角形。

按从右往左从上往下的顺序扫描每一个方向斜线上的点，考虑这个点作为▽下顶点的贡献。

假设这个点往左上，右上延伸的最大长度分别为UL和UR，那么相当于询问在向上min(UL, UR)的范围内有多少横线长度大于等于到枚举顶点的距离。

这个直观感觉不太好统计，那么反过来考虑每一条横线对于哪些▽下顶点是有效的。

假设在某点处向右的最大距离为R，那么这条横线对于它下方R范围内的顶点都是可以作为三角形▽上边的。

在扫描的过程中顺便维护好UL，UR和R，用一个树状数组维护这个斜线上横线的贡献，即在扫描到的时候+1，在下方R处加一个删除标记，扫到的时候删掉。

枚举下顶点的时候，只要在树状数组上询问一下min(UL, UR)范围内的有效横线数目。

时限很紧，不仅要比较好的读入还要常数小。

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

int f[66666];
inline int lowbit(int s) {
    return s & (-s);
}
inline void modify(int i, int x, int n) {
    while (i <= n) f[i] += x, i += lowbit(i);
}
inline int query(int i) {
    int ret = 0;
    while (i > 0) ret += f[i], i -= lowbit(i);
    return ret;
}
vector<int> del[66666];

int main() {
    ios_base :: sync_with_stdio(0);
    cin.tie(0);
    int r, c;
    cin >> r >> c;
    r = 2 * r - 1, c = 2 * c - 1;
    vector<string> s(r);
    getline(cin, s[0]);
    for(int i = 0; i < r; ++i) {
        getline(cin, s[i]);
        while(s[i].length() < c) s[i].push_back(' ');
    }
    ll ans = 0;
    for(int rot = 0; rot < 2; ++rot) {
        vector< vector<int> > R(r, vector<int>(c, 0));
        vector< vector<int> > UL(r, vector<int>(c, 0));
        vector< vector<int> > UR(r, vector<int>(c, 0));
        for(int j = c - 1; j >= 0; --j) {
            if(s[0][j] != 'x') continue;
            int maxi = min((r - 1) / 2, (c - 1 - j) / 2) + 1;
            for(int ii = 0, jj = j; ii < r && jj < c; ii += 2, jj += 2) {
                if(jj + 2 < c && s[ii][jj + 2] != ' ') R[ii][jj] = R[ii][jj + 4] + 1;
                if(ii >= 2 && jj >= 2 && s[ii - 1][jj - 1] != ' ') UL[ii][jj] = UL[ii - 2][jj - 2] + 1;
                if(ii >= 2 && jj + 2 < c && s[ii - 1][jj + 1] != ' ') UR[ii][jj] = UR[ii - 2][jj + 2] + 1;
                ans += query(ii / 2 + 1) - query(ii / 2 - min(UL[ii][jj], UR[ii][jj]));
                if(R[ii][jj]) {
                    modify(ii / 2 + 1, 1, maxi);
                    del[min(ii / 2 + 1 + R[ii][jj], maxi)].push_back(ii / 2 + 1);
                }
                for(auto x: del[ii / 2 + 1]) modify(x, -1, maxi);
                del[ii / 2 + 1].clear();
            }
        }
        for(int i = 1; i < r; i++) {
            if(s[i][0] != 'x') continue;
            int maxj = min((r - 1 - i) / 2, (c - 1) / 2) + 1;
            for(int ii = i, jj = 0; ii < r && jj < c; ii += 2, jj += 2) {
                if(jj + 2 < c && s[ii][jj + 2] != ' ') R[ii][jj] = R[ii][jj + 4] + 1;
                if(ii >= 2 && jj >= 2 && s[ii - 1][jj - 1] != ' ') UL[ii][jj] = UL[ii - 2][jj - 2] + 1;
                if(ii >= 2 && jj + 2 < c && s[ii - 1][jj + 1] != ' ') UR[ii][jj] = UR[ii - 2][jj + 2] + 1;
                ans += query(jj / 2 + 1) - query(jj / 2 - min(UL[ii][jj], UR[ii][jj]));
                if(R[ii][jj]) {
                    modify(jj / 2 + 1, 1, maxj);
                    del[min(jj / 2 + 1 + R[ii][jj], maxj)].push_back(jj / 2 + 1);
                }
                for(auto x: del[jj / 2 + 1]) modify(x, -1, maxj);
                del[jj / 2 + 1].clear();
            }
        }
        reverse(s.begin(), s.end());
    }
    cout << ans << endl;
    return 0;
}

Panda Preserve

由于圆半径一致，对于多边形内的每一个点，总是最先被距离自己最近的顶点覆盖到。

也即是说，每个顶点要覆盖到以自己为最近顶点的区域，即维诺图，又称泰森多边形，只要枚举顶点做中垂线即可得到这个凸多边形。

我们只关心这个凸多边形和原多边形交的部分，关键点只有两种情况：凸多边形顶点在原多边形内部；两多边形交点。

暴力求出关键点算距离取最大值即可。

需要抄的板子大概是一个中垂线，半平面交，点多边形位置关系。

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

typedef double db;
const db eps=1e-6;
int sign(db k){
    if (k>eps) return 1; else if (k<-eps) return -1; return 0;
}
int cmp(db k1,db k2){return sign(k1-k2);}
int inmid(db k1,db k2,db k3){return sign(k1-k3)*sign(k2-k3)<=0;}// k3 在 [k1,k2] 内
struct point{
    db x,y;
    point operator + (const point &k1) const{return (point){k1.x+x,k1.y+y};}
    point operator - (const point &k1) const{return (point){x-k1.x,y-k1.y};}
    point operator * (db k1) const{return (point){x*k1,y*k1};}
    point operator / (db k1) const{return (point){x/k1,y/k1};}
    int operator == (const point &k1) const{return cmp(x,k1.x)==0&&cmp(y,k1.y)==0;}
    // 逆时针旋转
    point turn90(){return (point){-y,x};}
    bool operator < (const point k1) const{
        int a=cmp(x,k1.x);
        if (a==-1) return 1; else if (a==1) return 0; else return cmp(y,k1.y)==-1;
    }
    db abs(){return sqrt(x*x+y*y);}
    int getP() const{return sign(y)==1||(sign(y)==0&&sign(x)==-1);}
};
int inmid(point k1,point k2,point k3){return inmid(k1.x,k2.x,k3.x)&&inmid(k1.y,k2.y,k3.y);}
db cross(point k1,point k2){return k1.x*k2.y-k1.y*k2.x;}
db dot(point k1,point k2){return k1.x*k2.x+k1.y*k2.y;}
// -pi -> pi
int compareangle (point k1,point k2){
    return k1.getP()<k2.getP()||(k1.getP()==k2.getP()&&sign(cross(k1,k2))>0);
}
point getLL(point k1,point k2,point k3,point k4){
    db w1=cross(k1-k3,k4-k3),w2=cross(k4-k3,k2-k3); return (k1*w2+k2*w1)/(w1+w2);
}
int intersect(db l1,db r1,db l2,db r2){
    if (l1>r1) swap(l1,r1); if (l2>r2) swap(l2,r2); return cmp(r1,l2)!=-1&&cmp(r2,l1)!=-1;
}
int checkSS(point k1,point k2,point k3,point k4){
    return intersect(k1.x,k2.x,k3.x,k4.x)&&intersect(k1.y,k2.y,k3.y,k4.y)&&
           sign(cross(k3-k1,k4-k1))*sign(cross(k3-k2,k4-k2))<=0&&
           sign(cross(k1-k3,k2-k3))*sign(cross(k1-k4,k2-k4))<=0;
}
int onS(point k1,point k2,point q){return inmid(k1,k2,q)&&sign(cross(k1-q,k2-k1))==0;}
struct line{
    // p[0]->p[1]
    point p[2];
    line(point k1,point k2){p[0]=k1; p[1]=k2;}
    point& operator [] (int k){return p[k];}
    int include(point k){return sign(cross(p[1]-p[0],k-p[0]))>0;}
    point dir(){return p[1]-p[0];}
};
point getLL(line k1,line k2){return getLL(k1[0],k1[1],k2[0],k2[1]);}
int parallel(line k1,line k2){return sign(cross(k1.dir(),k2.dir()))==0;}
int sameDir(line k1,line k2){return parallel(k1,k2)&&sign(dot(k1.dir(),k2.dir()))==1;}
int operator < (line k1,line k2){
    if (sameDir(k1,k2)) return k2.include(k1[0]);
    return compareangle(k1.dir(),k2.dir());
}
int checkpos(line k1,line k2,line k3){return k3.include(getLL(k1,k2));}
vector<line> getHL(vector<line> &L){ // 求半平面交 , 半平面是逆时针方向 , 输出按照逆时针
    sort(L.begin(),L.end()); deque<line> q;
    for (int i=0;i<(int)L.size();i++){
        if (i&&sameDir(L[i],L[i-1])) continue;
        while (q.size()>1&&!checkpos(q[q.size()-2],q[q.size()-1],L[i])) q.pop_back();
        while (q.size()>1&&!checkpos(q[1],q[0],L[i])) q.pop_front();
        q.push_back(L[i]);
    }
    while (q.size()>2&&!checkpos(q[q.size()-2],q[q.size()-1],q[0])) q.pop_back();
    while (q.size()>2&&!checkpos(q[1],q[0],q[q.size()-1])) q.pop_front();
    vector<line>ans; for (int i=0;i<q.size();i++) ans.push_back(q[i]);
    return ans;
}
int contain(vector<point>A,point q){ // 2 内部 1 边界 0 外部
    int pd=0; A.push_back(A[0]);
    for (int i=1;i<A.size();i++){
        point u=A[i-1],v=A[i];
        if (onS(u,v,q)) return 1; if (cmp(u.y,v.y)>0) swap(u,v);
        if (cmp(u.y,q.y)>=0||cmp(v.y,q.y)<0) continue;
        if (sign(cross(u-v,q-v))<0) pd^=1;
    }
    return pd<<1;
}

int main() {
    int n;
    double ans = 0;
    scanf("%d", &n);
    vector<point> p = vector<point>(n);
    for(int i = 0; i < n; ++i) scanf("%lf %lf", &p[i].x, &p[i].y);
    for(int i = 0; i < n; ++i) {
        vector<line> L;
        L.emplace_back(line{point{-20000, -20000}, point{20000, -20000}});
        L.emplace_back(line{point{20000, -20000}, point{20000, 20000}});
        L.emplace_back(line{point{20000, 20000}, point{-20000, 20000}});
        L.emplace_back(line{point{-20000, 20000}, point{-20000, -20000}});
        for(int j = 0; j < n; ++j) {
            if(i == j) continue;
            point mid = (p[i] + p[j]) / 2;
            L.emplace_back(line{mid, (p[j] - mid).turn90() + mid});
        }
        L = getHL(L);
        int sz = int(L.size());
        if(sz > 2) {
            vector<point> v = vector<point>(sz);
            for(int j = 0; j < sz; ++j) {
                v[j] = getLL(L[j], L[(j + 1) % sz]);
                if(contain(p, v[j])) ans = max(ans, (p[i] - v[j]).abs());
            }
            for(int j = 0; j < sz; ++j) {
                line l1 = line{v[j], v[(j + 1) % sz]};
                for(int k = 0; k < n; ++k) {
                    line l2 = line{p[k], p[(k + 1) % n]};
                    if(checkSS(v[j], v[(j + 1) % sz], p[k], p[(k + 1) % n])) {
                        point u = getLL(l1, l2);
                        ans = max(ans, (p[i] - u).abs());
                    }
                }
            }
        }
    }
    printf("%.8f
", ans);
    return 0;
}

Gem Island

考虑分批发放，每次给选中的人一批人各发一个宝石，例如第一步可以看成是给n个人各发一个宝石，第二步则在n个人中选择一个子集，第三步在第二步选中的人中再选择子集……

用f[i][j][k]表示第i批，已经发了j个宝石，目前选中的人集合大小为k的所有方案前r个人的宝石和，g[i][j][k]表示方案数。

转移考虑枚举k个人的子集l，方案数只要乘上C(k, l)，贡献增加是方案数乘min(r, l)。

最后用插板法除个总数就是期望。

第一维空间可以滚动数组，n4敢水敢过。

#include <bits/stdc++.h>
using namespace std;
double c[1005][1005], f[2][505][505], g[2][505][505];

int main() {
    for(int i = 0; i < 1005; ++i) c[i][0] = c[i][i] = 1;
    for(int i = 2; i < 1005; ++i)
        for(int j = 1; j < i; ++j)
            c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
    double ans = 0;
    int n, d, r, o = 0;
    scanf("%d %d %d", &n, &d, &r);
    f[0][0][n] = r, g[0][0][n] = 1;
    for(int i = 2; i <= d + 1; ++i) {
        o ^= 1;
        memset(f[o], 0, sizeof(f[o]));
        memset(g[o], 0, sizeof(g[o]));
        for(int j = 0; j <= d; ++j) {
            for(int k = 1; k <= n; ++k) {
                if(g[o ^ 1][j][k] == 0) continue;
                for(int l = 1; l <= k; ++l) {
                    if(j + l > d) break;
                    g[o][j + l][l] += g[o ^ 1][j][k] * c[k][l];
                    f[o][j + l][l] += f[o ^ 1][j][k] * c[k][l] + g[o ^ 1][j][k] * c[k][l] * min(l, r);
                }
            }
        }
        for(int k = 1; k <= n; ++k) ans += f[o][d][k];
    }
    printf("%.8f
", ans / c[d + n - 1][d]);
    return 0;
}

Getting a Jump on Crime

枚举格子对判断是否可达，先根据距离和高度差可以求出运动时间，注意判无解的情况，然后可以得到轨迹方程。

然后算这条轨迹在水平面投影的直线，计算投影和每条横线、纵线的交点位置，如果不在4个格子的角落则只要判两边，否则判四周。

最后随便bfs或者floyd一下。

无脑抄板的话只需要一个线段交的样子。

#include <bits/stdc++.h>
using namespace std;
const double g = 9.80665;
typedef pair<int, int> pii;
vector<pii> G[22][22];
int H[22][22];

typedef double db;
const db eps=1e-8;
int sign(db k){
    if (k>eps) return 1; else if (k<-eps) return -1; return 0;
}
int cmp(db k1,db k2){return sign(k1-k2);}
struct point{
    db x,y;
    point operator + (const point &k1) const{return (point){k1.x+x,k1.y+y};}
    point operator - (const point &k1) const{return (point){x-k1.x,y-k1.y};}
    point operator * (db k1) const{return (point){x*k1,y*k1};}
    point operator / (db k1) const{return (point){x/k1,y/k1};}
    int operator == (const point &k1) const{return cmp(x,k1.x)==0&&cmp(y,k1.y)==0;}
    bool operator < (const point k1) const{
        int a=cmp(x,k1.x);
        if (a==-1) return 1; else if (a==1) return 0; else return cmp(y,k1.y)==-1;
    }
    db abs(){return sqrt(x*x+y*y);}
};
db cross(point k1,point k2){return k1.x*k2.y-k1.y*k2.x;}
point getLL(point k1,point k2,point k3,point k4){
    db w1=cross(k1-k3,k4-k3),w2=cross(k4-k3,k2-k3); return (k1*w2+k2*w1)/(w1+w2);
}
int intersect(db l1,db r1,db l2,db r2){
    if (l1>r1) swap(l1,r1); if (l2>r2) swap(l2,r2); return cmp(r1,l2)!=-1&&cmp(r2,l1)!=-1;
}
int checkSS(point k1,point k2,point k3,point k4){
    return intersect(k1.x,k2.x,k3.x,k4.x)&&intersect(k1.y,k2.y,k3.y,k4.y)&&
           sign(cross(k3-k1,k4-k1))*sign(cross(k3-k2,k4-k2))<=0&&
           sign(cross(k1-k3,k2-k3))*sign(cross(k1-k4,k2-k4))<=0;
}

inline double sq(double x) {return x * x;}
inline double cal(double a, double b, double c, double x) {
    return a * x * x + b * x + c;
}
int ans[22][22];
int main() {
    int dx, dy, w, v, lx, ly;
    scanf("%d %d %d %d %d %d", &dx, &dy, &w, &v, &lx, &ly);
    for(int i = 1; i <= dy; ++i)
        for(int j = 1; j <= dx; ++j)
            scanf("%d", &H[i][j]);
    for(int i = 1; i <= dy; ++i) {
        for(int j = 1; j <= dx; ++j) {
            point p1 = point{(i - 0.5) * w, (j - 0.5) * w};
            for(int p = 1; p <= dy; ++p) {
                for(int q = 1; q <= dx; ++q) {
                    if(i == p && j == q) continue;
                    point p2 = point{(p - 0.5) * w, (q - 0.5) * w};
                    double h = H[p][q] - H[i][j];
                    double d = (p1 - p2).abs();
                    if(sq(v) < g * h || sq(g * h - sq(v)) < sq(g) * (sq(d) + sq(h))) continue;
                    double t = sqrt((sq(v) - g * h + sqrt(sq(g * h - sq(v)) - sq(g) * (sq(d) + sq(h)))) / (sq(g) / 2));
                    double cost = d / t / v;
                    double a = -0.5 * g / sq(v * cost), b = sqrt(1 - sq(cost)) / cost, c = H[i][j];
                    int ok = 1;
                    for(int o = 1; o < dy; ++o) {
                        point p3 = point{1.0 * w * o, 0.0};
                        point p4 = point{1.0 * w * o, 1.0 * w * dx};
                        if(checkSS(p1, p2, p3, p4)) {
                            point its = getLL(p1, p2, p3, p4);
                            double dis = (its - p3).abs() / w;
                            double ht = cal(a, b, c, (its - p1).abs());
                            if(abs(int(dis) - dis) < eps) {
                                int x1 = int(dis), x2 = x1 + 1;
                                if(ht < H[o][x1] || ht < H[o + 1][x1]) ok = 0;
                                if(ht < H[o][x2] || ht < H[o + 1][x2]) ok = 0;
                            }
                            else if(abs(int(dis) + 1 - dis) < eps) {
                                int x1 = int(dis) + 1, x2 = x1 + 1;
                                if(ht < H[o][x1] || ht < H[o + 1][x1]) ok = 0;
                                if(ht < H[o][x2] || ht < H[o + 1][x2]) ok = 0;
                            }
                            else {
                                int x = int(dis) + 1;
                                if(ht < H[o][x] || ht < H[o + 1][x]) ok = 0;
                            }
                        }
                    }
                    for(int o = 1; o < dx; ++o) {
                        point p3 = point{0.0, 1.0 * w * o};
                        point p4 = point{1.0 * w * dy, 1.0 * w * o};
                        if(checkSS(p1, p2, p3, p4)) {
                            point its = getLL(p1, p2, p3, p4);
                            double dis = (its - p3).abs() / w;
                            double ht = cal(a, b, c, (its - p1).abs());
                            if(abs(int(dis) - dis) < eps) {
                                int x1 = int(dis), x2 = x1 + 1;
                                if(ht < H[x1][o] || ht < H[x1][o + 1]) ok = 0;
                                if(ht < H[x2][o] || ht < H[x2][o + 1]) ok = 0;
                            }
                            else if(abs(int(dis) + 1 - dis) < eps) {
                                int x1 = int(dis) + 1, x2 = x1 + 1;
                                if(ht < H[x1][o] || ht < H[x1][o + 1]) ok = 0;
                                if(ht < H[x2][o] || ht < H[x2][o + 1]) ok = 0;
                            }
                            else {
                                int x = int(dis) + 1;
                                if(ht < H[x][o] || ht < H[x][o + 1]) ok = 0;
                            }
                        }
                    }
                    if(ok) G[i][j].emplace_back(pii(p, q));
                }
            }
        }
    }
    memset(ans, -1, sizeof(ans));
    queue<pii> q;
    q.push(pii(ly, lx));
    ans[ly][lx] = 0;
    while(!q.empty()) {
        pii tmp = q.front(); q.pop();
        int x = tmp.first, y = tmp.second;
        for(int i = 0; i < G[x][y].size(); ++i) {
            pii nxt = G[x][y][i];
            int xx = nxt.first, yy = nxt.second;
            if(ans[xx][yy] == -1) {
                ans[xx][yy] = ans[x][y] + 1;
                q.push(nxt);
            }
        }
    }
    for(int i = 1; i <= dy; ++i) {
        for(int j = 1; j <= dx; ++j) {
            if(ans[i][j] == -1) putchar('X');
            else printf("%d", ans[i][j]);
            printf("%c", j == dx ? '
' : ' ');
        }
    }
    return 0;
}

最后两题不看了西西