C++博客-From A Start,As An Acmer-随笔分类-UVAlive Solution Report

UVALIVE 5685 Difficult Routes ［最短路问题变形，坑爹题］

BUPT-[aswmtjdsj] @ Penalty — Fri, 28 Oct 2011 17:01:00 GMT

题目大意：
给你一个三维地图，里面N个点，给出对应的xyz坐标；给你M条边，连接对应编号的点。
每条边有两个值。
cost：两点的欧式距离。
d：两点的高度差（z轴差值的绝对值）除以两点在XY平面的投影的欧式距离，再乘以100，最后下取整，如果a点比b点高或者和b点持平，则d值为0。=>所以边有向。
给你一个起始点编号一个终点编号，再给你一个目标值d。
让你找一条最短路径（cost和最小），要求起点终点为对应的点，且这条路径上的最大d值为给定d值。起终点可能相同。

做法：
就是最短路嘛，特点是要求必须经过满足约束的边，那么就在松弛条件上面做手脚。
把dis数组开成两维的：dis[0][p]表示到该点还没满足条件时候的最短路，dis[1][p]表示到这点已经满足条件时候的最短路。
由于稀疏图，那么就开始spfa了。
从dis[0][s]=0开始，把其他所有值初始化置为－1或者inf。
松弛的时候这样，对于dis[0]，该咋松弛就咋松弛。
对于邻接表中当前边的d值等于给定d值，那么就用当前点的min(dis[0][now],dis[1][now])去更新下一点的dis[1][p]；
对于不等的情况，如果当前点的dis[1][now]不等于－1或者inf，那么就用dis[1][now]去更新dis[1][p]。
然后就完了。答案就是dis[1][t]。inf或者ans。

坑爹之处在于题目中N和M的数据范围少给了个0，RE到死哇。。一开始还tmd TLE。。。擦。。。

话说某些小盆友还用了spfa求最小环的想法，我觉得没必要的说。把满足条件后的点和不满足条件的点当成不同的点，那么根本就不存在环的问题了。。
对于起终点相同的情况，最短路径实际上的松弛方式就是i->j~k->i'。。。看嘛，哪里有环了。

附代码：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <queue>
using namespace std;
int n,m,s,t,d;
#define maxn 110005
#define maxm 110005
const double eps = 1e-8;
int sgn(double x){return fabs(x) < eps ? 0 : x < -eps ? -1 : 1;}
struct edge
{
    int p,next,d;
    double c;
    edge(){}
    edge(int a,int b,int _c,double _d):p(a),next(b),d(_c),c(_d){}
}e[maxm];
int tot;
struct point
{
    double x,y,z;
    point(){}
    point(double a,double b,double c):x(a),y(b),z(c){}
    point operator - (const point p)
    {
        return point(x - p.x,y - p.y,z - p.z);
    }
    double norm()
    {
        return sqrt(x * x + y * y + z * z);
    }
    double norm2()
    {
        return sqrt(x * x + y * y);
    }
}p[maxn];
int st[maxn];
void init()
{
    tot = 0;
    fill(st,st + n + 1,-1);
}
void add(int p,int q,int d,double c)
{
    e[tot] = edge(q,st[p],d,c);
    st[p] = tot++;
}
double dis[2][maxn];
bool in[maxn];
void bfs()
{
    for(int i = 0;i < 2;i++)
        for(int j = 1;j <= n;j++)
            dis[i][j] = -1.0;
    fill(in,in + n + 1,0);
    queue <int> Q;
    Q.push(s);
    in[s] = true;
    dis[0][s] = 0.0;
    while(!Q.empty())
    {
        int now = Q.front();
        Q.pop();
        in[now] = false;
        for(int k = st[now];~k;k = e[k].next)
        {
            bool mark = false;
            int p = e[k].p;
            int dd = e[k].d;
            double cost = e[k].c;
            if(dd > d)
                continue;
            //cout << p << ' ' << dd << ' ' << cost << endl;
            if(sgn(dis[0][p]+1) == 0 || sgn(dis[0][p] - dis[0][now] - cost) > 0)
                dis[0][p] = dis[0][now] + cost,mark = true;
            if(dd == d)
            {
                double tmp ;
                if(sgn(dis[1][now] + 1.0) != 0)
                    tmp = min(dis[0][now],dis[1][now]);
                else
                    tmp = dis[0][now];
                if(sgn(dis[1][p] + 1.0) == 0 || sgn(dis[1][p] - tmp - cost) > 0)
                    dis[1][p] = tmp + cost,mark=true;
            }
            else if(sgn(dis[1][now]+1) != 0)
            {
                double tmp = dis[1][now];
                if(sgn(dis[1][p] + 1.0) == 0 || sgn(dis[1][p] - tmp - cost) > 0)
                    dis[1][p] = tmp + cost,mark=true;
            }
            if(mark && !in[p])
            {
                Q.push(p);
                in[p] = true;
            }
            //if(Q.size() > 100000)
            //    cout << "fuck" << endl;
        }
    }
}
void gao()
{
    double x,y,z;
    for(int i = 1;i <= n;i++)
    {
        scanf("%lf %lf %lf",&x,&y,&z);
        p[i] = point(x,y,z);
    }
    init();
    for(int i = 0;i < m;i++)
    {
        int a,b;
        scanf("%d %d",&a,&b);
        int fuck = (int)floor(100 * fabs((p[b].z - p[a].z)) / (p[a] - p[b]).norm2());
        double l = (p[a] - p[b]).norm();
        if(sgn(p[a].z - p[b].z) < 0)
        {
            add(a,b,fuck,l);
            add(b,a,0,l);
        }
        else
        {
            add(b,a,fuck,l);
            add(a,b,0,l);
        }
    }
    scanf("%d %d %d",&s,&t,&d);
    bfs();
    double ans = dis[1][t];
    //for(int i = 1;i <= n;i++)
    //    printf("%.3lf %.3lf\n",dis[0][i],dis[1][i]);
    if(sgn(ans + 1.0) == 0)
        puts("None");
    else
        printf("%.3lf\n",ans);
}
int main()
{
    while(scanf("%d %d",&n,&m) == 2 && (n || m))
        gao();
}

BUPT-[aswmtjdsj] @ Penalty 2011-10-29 01:01 发表评论

二维 & 三维费马点问题【没有理论研究，只有代码研究】

BUPT-[aswmtjdsj] @ Penalty — Fri, 09 Sep 2011 12:23:00 GMT

模拟退火什么的我只知道一个大概思想，然后会很矬的去实现它。近似算法真心伤不起啊唉。
例题：poj 2420 【二维多边形费马点】， uva 5102 【福州现场赛E题，四边形费马点，有结论，所以模拟退火应该不算正解】， ZOJ 2928 【三维费马点】。

模拟退火神马的就是一个迭代过程，在每次迭代中向所有可能的方向试探，然后选取其中最优的一个作为下一次的迭代起点；为了让迭代能够终止，设定了一个步长，每次迭代之后步长乘以一个小于1的系数来减小步长。
迭代方式是相同的，就是向所有可能的方向试探，再按规则模拟计算结果，比如二维点就是向8个方向试探之后再计算到所有点的距离和，而三维点就是26个方向了。
初始步长作为上界，这个该怎么设定我一直不太清楚，我反正是用最大可能步长作为上界的；初始迭代点，随手设置一个吧，我用的是所有点坐标的算术平均数，也可以用原点之类，但是我觉得无论选择啥点都不能保证绝对的正确性的吧（否则，“图灵奖”。。。）；迭代步长系数，好像我的写法比较矬？导致我必须把系数设到0.993以上才能过题，真是弱爆了；至于精度下界就设为1e-10就好了，反正不要钱，哈。

模拟退火的一大弊端在于，如果进入了某个次优解点的邻域，且此时步长已经很小的话，那很有可能就会陷入这个次优解邻域的漩涡里（俗话说叫掉坑里？好像有专业名词叫鞍点或者涡点什么的？我数学不太好不好意思。。），然后再也跑不出来。所以近似算法毕竟是“近似”算法，想避免掉入坑里，只能去优化写法或者找出答案的某种规律性，来分段或者剪枝迭代什么的。。我是玩不转这个了，如上所述的三题，我加起来交了五六十次了吧？总之是没有找到一组又能ac又快的好参数。唉。
我若爆了。。

附代码吧，以2928题为例：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#define maxn 105
const double eps = 1e-12;
int comp(double x)
{
    if(fabs(x) < eps)
        return 0;
    else if(x < -eps)
        return -1;
    else
        return 1;
}
using namespace std;
struct point
{
    double x,y,z;
    point(double a = 0,double b = 0,double c = 0):x(a),y(b),z(c){}
    point operator - (const point p)
    {
        return point(x - p.x,y - p.y,z - p.z);
    }
    point operator + (const point p)
    {
        return point(x + p.x,y + p.y,z + p.z);
    }
    double norm()
    {
        return sqrt(x * x + y * y + z * z);
    }
    point operator *(double a)
    {
        return point(x * a,y * a,z * a);
    }
}p[maxn],fermat,dir[30];
int n;
int main()
{
    while(scanf("%d",&n) == 1)
    {
        for(int i = 0;i < n;i++)
            scanf("%lf %lf %lf",&p[i].x,&p[i].y,&p[i].z);
        int cnt = 0;
        for(int i=-1;i<=1;i++)
            for(int j=-1;j<=1;j++)
                for(int k = -1;k <= 1;k++)
                    dir[cnt++] = point(i,j,k);
        double step = 100;
        point now,ans;
        double temp = 1e10,calc;
        point sel;
        for(int i = 0;i < n;i++)
            ans = ans + p[i];
        ans = ans * (1.0 / (double)n);
        while(step > eps)
        {
            sel = ans;
            for(int i = 0;i < cnt;i++)
            {
                calc = 0.0;
                now = ans + dir[i] * step;
                for(int idx = 0;idx < n;idx++)
                    calc += (p[idx] - now).norm();
                if(comp(calc - temp) < 0)
                {
                    sel = now;
                    temp = calc;
                }
            }
            ans = sel;
            step *= 0.993;
        }
        printf("%.3f %.3f %.3f\n",ans.x,ans.y,ans.z);
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-09 20:23 发表评论

UVA 12017 Imitation 【有向图传递闭包的几个结论】【2011上海邀请赛I题】

BUPT-[aswmtjdsj] @ Penalty — Thu, 08 Sep 2011 12:10:00 GMT

题目大意是给你一个1000个点10000条边的有向图，让你求出与原图等价的传递闭包的最少边和最多边。
解法：
最多边好求，就dfs一下（floyd的邻接表版）算出闭包，统计一下邻接矩阵中1的个数再减去自环即为答案。
最少边稍微复杂一点：
首先图的强联通分量内的边都是必要边，而两两分量之间去掉多重边即可。
关键点是多重边的去除：强联通分量缩点以后，在新图上从每点开始用bfs或者dp做最长路（因为如果某条重复边跨越了某条路径的话，那么对于路径起点来说，路径终点的距离一定不是由这条重复边松弛的），对于每个点，存在几个距离为1的点计数器就加几，然后再加上每个强联通分量之中的边数即可（对于点数大于1的强联通分量，边数=点数）。
纠结，知道怎么捉，不知怎么说，我太弱了。对于纯图论的问题的想法还是太弱了。

附代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#include <queue>
#define maxn 1005
#define maxm 10005
bool map[maxn][maxn];
int n,m,tot,newtot;
int st[maxn];
int sc[maxn],newst[maxn],pre[maxn],low[maxn],s[maxn],color[maxn];
bool vis[maxn];
bool viscolor[maxn],colorvis[maxn];
int N,cnt0,cnt1;
int d[maxn];
int mmm,MMM;
struct edge
{
    int p,next;
    edge(){}
    edge(int a,int b):p(a),next(b){}
}e[maxm],newe[maxm];
void init()
{
    newtot = 0;
    tot = cnt0 = cnt1 = N = 0;
    fill(newst,newst + n + 1,-1);
    fill(st,st + n + 1,-1);
    fill(vis,vis + n + 1,0);
    fill(color,color + n + 1,0);
    fill(pre,pre + n + 1,-1);
    fill(low,low + n + 1,-1);
    for(int i = 1;i <= n;i++)
        for(int j = 1;j <= n;j++)
        {
            if(i == j)
                map[i][j] = 1;
            else
                map[i][j] = 0;
        }
}
void add(int p,int q)
{
    e[tot] = edge(q,st[p]);
    st[p] = tot++;
}
void newadd(int p,int q)
{
    newe[newtot] = edge(q,newst[p]);
    newst[p] = newtot++;
}
void dfs(int u,int v)
{
    map[u][v] = 1;
    for(int k = st[v];~k;k = e[k].next)
        if(map[u][e[k].p] == 0)
            dfs(u,e[k].p);
}
void scc(int now)
{
    int v,mm;
    mm = low[now] = pre[now] = cnt0++;
    s[N++] = now;
    for(int k = st[now];~k;k = e[k].next)
    {
        if(pre[e[k].p] == -1)
            scc(e[k].p);
        if(low[e[k].p] < mm)
            mm = low[e[k].p];
    }
    if(mm < low[now])
    {
        low[now] = mm;
        return ;
    }
    do
    {
        sc[(v = s[--N])] = cnt1;
        low[v] = n;
    }while(s[N] != now);
    cnt1++;
}
void bfs(int x)
{
    fill(d,d + cnt1 + 1,0);
    queue <int> Q;
    Q.push(x);
    while(!Q.empty())
    {
        int now = Q.front();
        Q.pop();
        for(int k = newst[now];~k;k = newe[k].next)
        {
            if(d[newe[k].p] < d[now] + 1)
            {
                d[newe[k].p] = d[now] + 1;
                Q.push(newe[k].p);
            }
        }
    }
    for(int i = 0;i < cnt1;i++)
        if(d[i] == 1)
            mmm++;
}
void gao()
{
    scanf("%d %d",&n,&m);
    init();
    for(int i = 0;i < m;i++)
    {
        int a,b;
        scanf("%d %d",&a,&b);
        add(a,b);
    }
    for(int i = 1;i <= n;i++)
        dfs(i,i);
    mmm = 0,MMM = 0;
    for(int i = 1;i <= n;i++)
        for(int j = 1;j <= n;j++)
            if(map[i][j])
                MMM++;
    MMM -= n;
    for(int i = 1;i <= n;i++)
        if(pre[i] == -1)
            scc(i);
    for(int i = 1;i <= n;i++)
    {
        color[sc[i]]++;
        for(int k = st[i];~k;k = e[k].next)
            if(sc[i] != sc[e[k].p])
                newadd(sc[i],sc[e[k].p]);
    }
    for(int i = 0;i < cnt1;i++)
        bfs(i);
    for(int i = 0;i < n;i++)
        if(color[i] > 1)
            mmm += color[i];
    printf("%d %d\n",mmm,MMM);
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int i = 1;i <= t;i++)
    {
        printf("Case #%d: ",i);
        gao();
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-08 20:10 发表评论

UVA 5100 && FZU 2002 Shade of Hallelujah Mountain 【三维旋转、投影+凸包】

BUPT-[aswmtjdsj] @ Penalty — Wed, 07 Sep 2011 02:03:00 GMT

摘要: 好恶心的一题。给一个点，一个多面体，一个平面，假设点是光源，那么就问，多面体在平面上的投影面积为多少。做法：hint还是比较人道的，提示了旋转平面把三维凸包转成二维凸包的方法。（其实不能算是三维凸包，只不过是三维空间内的二维凸包；hint转化之后就变成了二维空间的二维凸包。）平面给的是平面方程Ax+By+Cz=D，那么平面法向量为(A,B,C)。目标是把平面旋转到和Z平面平行。根据hint的提示，... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-09-07 10:03 发表评论

UVALIVE 4654 Tracking Robots 【最小路径覆盖】

BUPT-[aswmtjdsj] @ Penalty — Sun, 21 Aug 2011 14:35:00 GMT

学二分图那么久，真是白学了，妥妥的最小路径覆盖都木有看出来。弱爆了。
链接：http://livearchive.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2655

给你一个图，最多有100个点，一开始有很多（不知道多少）个机器人在编号为1的点上，现在机器人开始移动，每当有一个机器人进入一个新点的时候，就会报出新点的编号。现在我们得到了一个长度不超过200的报号序列，想知道一开始最多和最少有几个机器人。注意所谓的新点即“与报号机器人之前所在的点不同”，所以每当一个机器人移动到下一个点时就会发生报号，并且机器人可以往复运动。

对于最多有多少个机器人，可以有一个猜想，即如果所有的报号均为不同的机器人报出的，可能吗？如果不可能，什么样的情况不可能？即，不和1点直接相连的点的编号显然不可能是由新出现的机器人报出的。所以，最大的机器人数量即为报号序列中与1号点相连的点的编号出现的次数。

对于最少有多少个机器人，那么裸的最小路径覆盖模型啊。我个蒟蒻。
模型转化：我们怎样才能使机器人最少呢？即是让尽量少的机器人去报这个报号序列：如果把报号序列抽象成一个有向新图的话，就用尽量的少的路径来覆盖这个新图。最小路径覆盖模型即得。
建图方式：M^2建图，对于序列中的每个点枚举它之后的点列，看在原图中两点是否相连，如果相连，则在新图中连一条有向边。
然后匈牙利，再然后就M-二分图最大匹配即为答案。

（蒻弼，你不打错下标能死啊？你认真点能死啊！）

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 205
int mac[maxn];
bool vis[maxn],graph[maxn][maxn],old[maxn][maxn];
int n,m;
int input[maxn];
bool find(int x)
{
    for(int i = 1;i <= m;i++)
        if(graph[x][i] && !vis[i])
        {
            vis[i] = true;
            if(!mac[i] || find(mac[i]))
            {
                mac[i] = x;
                return true;
            }
        }
    return false;
}
int main()
{
    while(scanf("%d%d",&n,&m) == 2 && (n || m))
    {
        memset(old,0,sizeof(old));
        memset(graph,0,sizeof(graph));
        memset(mac,0,sizeof(mac));
        for(int i = 1;i <= n;i++)
        {
            int c;
            scanf("%d",&c);
            for(int j = 1;j <= c;j++)
            {
                int a;
                scanf("%d",&a);
                old[i][a] = true;
            }
        }
        int ans2 = 0;
        for(int i = 1;i <= m;i++)
        {
            scanf("%d",&input[i]);
            if(old[1][input[i]])
                ans2++;
        }
        for(int i = 1;i <= m;i++)
            for(int j = i + 1;j <= m;j++)
                if(old[input[i]][input[j]])
                    graph[i][j] = true;
        int ans1 = m;
        for(int i = 1;i <= m;i++)
        {
            fill(vis,vis + m + 1,0);
            if(find(i))
                ans1--;
        }
        printf("%d %d\n",ans1,ans2);

    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-21 22:35 发表评论

UVALIVE 4856 - OmniGravity 【一般小恶心的搜索】

BUPT-[aswmtjdsj] @ Penalty — Sun, 14 Aug 2011 07:15:00 GMT

摘要: Root :: Regionals 2010 :: Asia - DhakaIn this problem, we will play with four 2 x 2 squared pieces, an 8 x 8 board, few obstacles and gravit... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-08-14 15:15 发表评论