给出一个有向图，要求从1号点走到n号点，每条单向路径有a和b信息
走过一条边会提升a点等级，但会消耗log2(（level+ai)/level)的积分，
但是如果这个cost小于b那么是不能走这条边的，要求到n点的支付的总积分
最少。
思路：如果已经找出了一条到n点的路径，那么cost相加 log2(level2/level1)+log2(level3/level2)
+....+=log2(leveln) ,所以只要到最后的等级最小那么积分和当然就最小
所以求最短路，然后每走一个边判断能否走，注意用double可能（应该）会wa
判断可以手动判断，最后答案输出也需要手动log2
（ps：spfa超时？？...，dijkstra可以过）
#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <queue>
#include <cmath>
using namespace std;
typedef long long ll;
const int maxn=1e5;
const double eps=1e-6;
const ll INF=1e18;
struct Edge
{
ll u,v,a,b;
int nex;
};
struct HeapNode
{
ll d,u;
bool operator <(const HeapNode &rhs) const
{
return d>rhs.d;
}
};
vector<Edge> edges;
vector<int> G[maxn+100];
int last[maxn+100];
ll d[maxn+100],inq[maxn+100],pre[maxn+100],n,m;
double limit[2*maxn+100];
bool done[maxn+100];
void spfa(int s);
void AddEdge(int u,int v,int a,int b);
void dijkstra(int s);
ll Findlog(ll val);
bool judge(ll val,ll a,ll b);
int main()
{
int t,m;
ll u,v,a,b;
scanf("%d",&t);
while(t--)
{
scanf("%d%d",&n,&m);
// memset(last,0,sizeof(last));
for(int i=1;i<=n;i++) G[i].clear();
edges.clear();
for(int i=1;i<=m;i++)
{
scanf("%lld%lld%lld%lld",&u,&v,&a,&b);
AddEdge(u,v,a,b);
}
dijkstra(1);
if(d[n]==INF)
printf("-1\n");
else
printf("%lld\n",Findlog(d[n]));
}
return 0;
}
void AddEdge(int u,int v,int a,int b)
{
edges.push_back(Edge{u,v,a,b});
G[u].push_back(edges.size()-1);
/* if(b==0)
limit[edges.size()-1]=1e18;
else
limit[edges.size()-1]=a*1.0/((1<<b)-1);*/
}
void spfa(int s)
{
for(int i=1;i<=n;i++)
{
d[i]=INF;
inq[i]=0;
}
//memset(inq,0,sizeof(inq));
d[s]=1;inq[s]=1;pre[s]=0;
queue<int> Q;
Q.push(s);
while(!Q.empty())
{
int u=Q.front();Q.pop();
inq[u]=0;
for(int i=0;i<G[u].size();i++)
{
Edge& e=edges[G[u][i]];
if(d[u]+e.a<d[e.v]&&judge(d[u],e.a,e.b))
{
d[e.v]=d[u]+e.a;
pre[e.v]=u;
if(!inq[e.v])
{
Q.push(e.v);
inq[e.v]=1;
}
}
}
}
}
void dijkstra(int s)
{
priority_queue<HeapNode> Q;
for(int i=1;i<=n;i++) d[i]=INF;
d[s]=1;
memset(done,0,sizeof(done));
Q.push((HeapNode){1,s});
while(!Q.empty())
{
HeapNode x=Q.top();Q.pop();
int u=x.u;
if(done[u]) continue;
done[u]=true;
for(int i=0;i<G[u].size();i++)
{
Edge& e=edges[G[u][i]];
if(d[e.v]>d[u]+e.a&&judge(d[u],e.a,e.b))
{
d[e.v]=d[u]+e.a;
Q.push((HeapNode){d[e.v],e.v});
}
}
}
}
ll Findlog(ll val)
{
ll ans=0;
while(val)
{
ans++;
val>>=1;
}
ans--;
return ans;
}
bool judge(ll val,ll a,ll b)
{
ll ans=1;
for(int i=0;i<b;i++)
ans<<=1;
ans--;
if(ans==0||a/ans>=val)
return true;
return false;
}