牛妹游历城市（最短路补题

题目传送门

示例1

输入2

6 2 3 5 8 13 21 12 1 2 3 4 5 6 7 8 9 10 11 12

2
6
2 3 5 8 13 21
12
1 2 3 4 5 6 7 8 9 10 11 12

输出

3 5

3
5

示例2

输入 5

3 1 2 3 4 177 188 199 211 2 1 2 4 1 1 1 1 5 1 2 4 8 16

5
3
1 2 3
4
177 188 199 211
2
1 2
4
1 1 1 1
5
1 2 4 8 16

输出 1

1 Impossible 1 Impossible

1
1
Impossible
1
Impossible

第一次遇到建虚点做中介的题（绝不是因为是个废物而懒得刷题）。首先考虑暴力建路径，n²的复杂度明显超时。考虑二进制优化，对32个二进制位建32个虚点，对于每个点如果该点二进制第 j 位为1，则该点的与虚点的边权值为 1<<j。虚点指向实点的边权为 0。

跑一个最后dijkstra即可。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int qs=1e5+500;
const ll inf=1e18;
ll T,n,d[qs];
bool u[qs];
struct node{
    int y; ll p;
    node(){}
    node(int y,ll p):y(y),p(p){};
    /*bool operator < (const node &tem) const{
        return y>tem.y;
    }*/            
    //    本来想重载运算符将优先队列变成小根对，出了点问题 qwq 
}t;

vector<node> vc[qs];        // 不会链式前向星 qwq 
priority_queue<pair <ll,int > > q;

void dijkstra(){
    q.push(make_pair(0,1));
    while(q.size()){
        int x=q.top().second; q.pop();    //取出堆顶 
        if(u[x]) continue; u[x]=true;
        for(int i=0;i<vc[x].size();++i){    //访问每一个相邻节点 
            int y=vc[x][i].y;ll p=vc[x][i].p;
            if(d[y]>d[x]+p){
                d[y]=d[x]+p;            //更新最短路 
                q.push(make_pair(-d[y],y));        //pair第一维dist相反数，变成小根堆 
            }
        }    
    }
}
int main(){
    cin>>T;
    while(T--){
        cin>>n; ll  fx;
        // 初始化 
        for(int i=0;i<=n+200;++i) d[i]=inf,vc[i].clear(); d[1]=0;
        memset(u,false,sizeof(u));
        for(int i=1;i<=n;++i){
            cin>>fx;
            for(int j=0;j<=31;++j){
                if(fx & (1ll<<j)){    //与虚点建边 
                    ll a=1ll<<j;
                    vc[i].push_back(node(n+j+1,a));
                    vc[n+1+j].push_back(node(i,0));
                }
            }
        }
        dijkstra();
        if(d[n]>=inf) cout<<"Impossible
";
        else cout<<d[n]<<"
";
    }
    return 0;
}

//老废宅了.jpg

it(5)=lowbit((101)2)=1, lowbit(8)=lowbit((1000)2)=8