bytedance-016. 16. 最短移动距离

鉴于这道《简单》题竟然没有一篇题解？？， 我在这里分享一种做法吧

---

首先维护一个数组 f 代表每个结点到子树中有房子结点的最短距离


为了方便， 也同时存一下这个结点的编号

    pair<int, int> f[500500];

其中第一个成员代表最短距离， 第二个成员代表该结点编号
将房屋信息读入后可以从下向上初始化整棵树的结点信息

即

如果该节点 i 有房屋 ， 则将 f[i] 的第一项初始化为 0 ， 第二项初始化为自己(i)

如果没有， 那么将 f[i] 第一项更新为 左孩子 或 右孩子 的最小值 + 1

void update(int x) {
    if(a[x]) { // 当前结点x有房间
        f[x] = make_pair(0, x);// 则最小距离为零
    }
    else {
        f[x] = make_pair(maxn, maxn); // 否则在初始化时初始化为极大值
    }
    int y = x * 2; //左孩子
    if(y <= n && f[y].first + 1 < f[x].first) {
        f[x] = make_pair(f[y].first + 1, f[y].second);//  更新当前结点最新值
    }
    if(++y <= n && f[y].first + 1 < f[x].first) {
        f[x] = make_pair(f[y].first + 1, f[y].second);//  更新当前结点最新值
    }
}

接着， 我们读入每只松鼠的信息

对于每只松鼠， 我们维护一个 now 来表示该松鼠到最近房屋的距离以及结点编号

假设松鼠位于 结点 x，

• 首先我们将 now 初始化为 f[x] , 即， 当前点到其子树房屋的最优解
• 然后我们判断 是否前往其父节点更优

void query(int x, int w) {
    if(f[x].first + w < now.first){ // 维护最短路径
        lca = x; now = make_pair(f[x].first + w, f[x].second);
    }// 更新松鼠位置和最近房屋位置的最近公共祖先
    if(x != 1) {
        query(x / 2, w + 1); //判断其父节点是否更优, 
    }// 若更优将其父亲更新为新的 lca
}

然后将当前最优结点now的位置的房屋 - 1

同时因为房屋减少， 需要更新整棵树的f数组的值

完整代码? (大雾)

#include<bits/stdc++.h>
using namespace std;
const int maxn = 0x7f7f7f7f;
int a[500500];

int ans;
int n, m;
int lca; 
pair<int, int> f[500500];
int dir[500500];
pair<int, int> now; 

void update(int x) {
    if(a[x]) { 
        f[x] = make_pair(0, x);
    }
    else {
        f[x] = make_pair(maxn, maxn);
    }
    int y = x * 2;
    if(y <= n && f[y].first + 1 < f[x].first) {
        f[x] = make_pair(f[y].first + 1, f[y].second);
    }
    if(++y <= n && f[y].first + 1 < f[x].first) {
        f[x] = make_pair(f[y].first + 1, f[y].second);
    }
}

void query(int x, int w) {
    if(f[x].first + w < now.first){
        lca = x; now = make_pair(f[x].first + w, f[x].second);
    }
    if(x != 1) {
        query(x / 2, w + 1);
    }
}

int main() {
    cin>> n >> m;
    for(int i = 1; i <= n; i++){
        cin >> a[i];
    }
    for(int i = n; i >= 1; i--) {
        update(i);
    }
    for(int i = 1; i <= m; i++) {
        int x;
        cin >> x;
        now = make_pair(maxn, maxn);
        query(x, 0);
        ans += now.first;
        a[now.second]--;
        for(; x; x >>= 1) {
            update(x);
        }
    }
    cout << ans << endl;
    // system("pause");
    return 0;
}

然后交上去一看

笑嘻了

---

后来我们观察可以发现两个反例

即 ： 如果一个松鼠选择了他上面的房屋， 将会造成他上面的松鼠绕远选择其下较远的房屋，此时

局部最优解不能代表全局最优解

同理

如果一个松鼠选择的结点位于 lca 另一侧， 此时位于该结点下面的松鼠就会绕远到前一只松鼠下面

---

解决办法

维护一个路径方向标记数组dir， 通过判断其正负来处理两种反例中全局最优解


首先在第一种情况中

第一只松鼠选择其上方的房屋， 如果其上有松鼠想要选择前一只松鼠下面的房屋， 此时交换他们的房屋， 显然易见， 答案更优

void shang(int x) {// 当前松鼠选择上面的房屋
    update(x);// 为了防止更上面的松鼠绕远到更下面的房屋
    if(x == lca) return;// 交换两个松鼠的选择
    dir[x]--;//即 标记路径方向
    shang(x / 2);// 更新他的父亲 直到当前 lca 为止
}

同理

void xia(int x) {
    update(x);// 当前松鼠选择了 lca 下面的房屋
    if(x == lca) return;// 为防止下个松鼠绕远到前一个松鼠下面
    dir[x]++;// 交换两个松鼠的选择
    xia(x / 2);//利用 标记路径方向维护两个松鼠的最小路径和
}

然后在修改在 update 和 query 函数中的更新逻辑

AC代码

---

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

const int maxn = 0x7f7f7f7f;
int a[500500];// 房间
int ans;
int n, m;
int lca; // 最近公共祖先
pair<int, int> f[500500];// 结点i到其子树中房屋的最短距离及编号
int dir[500500];// 标记路径方向
pair<int, int> now; // 当前最近有房屋的结点信息
int cal(int x, int y) {
    return x * y < 0 ? -1 : 1; //判断当前路径方向
}

void update(int x) {
    if(a[x]) { // 当前结点x有房间
        f[x] = make_pair(0, x);// 则最小距离为零
    }
    else {
        f[x] = make_pair(maxn, maxn); // 否则在初始化时初始化为极大值
    }
    int y = x * 2; //左孩子
    if(y <= n && f[y].first + cal(dir[y], 1) < f[x].first) {
        f[x] = make_pair(f[y].first + cal(dir[y], 1), f[y].second);//  更新当前结点最新值
    }
    if(++y <= n && f[y].first + cal(dir[y], 1) < f[x].first) {
        f[x] = make_pair(f[y].first + cal(dir[y], 1), f[y].second);//  更新当前结点最新值
    }
}

void query(int x, int w) {
    if(f[x].first + w < now.first){ // 维护最短路径
        lca = x; now = make_pair(f[x].first + w, f[x].second);
    }// 更新松鼠位置和最近房屋位置的最近公共祖先
    if(x != 1) {// 标记路径方向决定更新方式
        query(x / 2, w + cal(dir[x],-1)); //判断其父节点是否更优, 
    }// 若更优将其父亲更新为新的 lca
}

void shang(int x) {// 当前松鼠选择上面的房屋
    update(x);// 为了防止更上面的松鼠绕远到更下面的房屋
    if(x == lca) return;// 交换两个松鼠的选择
    dir[x]--;//即 标记路径方向
    shang(x / 2);// 更新他的父亲 直到当前 lca 为止
}

void xia(int x) {
    update(x);// 当前松鼠选择了 lca 下面的房屋
    if(x == lca) return;// 为防止下个松鼠绕远到前一个松鼠下面
    dir[x]++;// 交换两个松鼠的选择
    xia(x / 2);//利用 标记路径方向维护两个松鼠的最小路径和
}

int main() {
    cin>> n >> m;
    for(int i = 1; i <= n; i++){
        cin >> a[i];// 录入房屋信息
    }
    for(int i = n; i >= 1; i--) {
        update(i); // 初始化当前结点到最近房间距离以及房间编号
    }//             从下往上更新
    for(int i = 1; i <= m; i++) {
        int x;
        cin >> x;// 读入一个松鼠的位置
        now = make_pair(maxn, maxn);
        query(x, 0); // 根据松鼠位置找最近房屋, 赋值给now
        ans += now.first; // 将now中的最短距离计入ans中
        shang(x);
        a[now.second]--; // 当前now标记的结点位置, 房屋数量 - 1
        xia(now.second);
        for(; x; x >>= 1) {// 由于减少了房屋
            update(x); // 更新其祖先节点的值
        }
    }
    cout << ans << endl;
    // system("pause");
    return 0;
}