HDU 4281 Judges' response dp+tsp极致

最新推荐文章于 2024-07-28 11:47:02 发布

原创最新推荐文章于 2024-07-28 11:47:02 发布 · 1.1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#ini #任务 #struct

2012 网络赛整理专栏收录该内容

20 篇文章

订阅专栏

本文探讨了解决特定竞赛问题的算法策略，包括通过动态规划实现最优裁判分配及路径规划，以确保所有参赛者都能在限制时间内被有效检查。算法采用多项优化技术，如子集枚举和最短路径查找，以高效地解决资源分配和路径优化问题。

题意：给定n（n<=16）个选手，每个选手展示limit时间，现在有若干裁判，每个裁判能接受选手展示的总时间是m，且裁判都从（x1，y1）出发，
任意两点间的距离是ceil(sqrt((xi - xj) ^ 2 + (yi - yj) ^ 2))。

问题1：最少需要多少个裁判能完成所有选手的检查任务；

问题2（和问题1没有关系，只是在问题1有解的情况下）：安排裁判数量任意多，求完成任务的裁判走的最短时间和。

题解：对于问题1：考虑dp[i]表示i状态下完成任务的最小裁判数，需要枚举当前状态i的子集，这个枚举过程很牛X，时间复杂度大概O（2^16 * 2^7）。

对于问题2：先对原图在一个裁判忍受范围内求tsp，并更新出数组dis[i]表示一个裁判走i状态并返回到（x1，y1）点的最小值，枚举子集得到答案。
dp[i] = MIN（dp[i] ，dp[i^j] +dis[j]）;

Sure原创，转载请注明出处。

#include <iostream>
#include <cstdio>
#include <memory.h>
#define sqr(x) ((x) * (x))
#define MIN(a , b) ((a) < (b) ? (a) : (b))
using namespace std;
const int inf = 1 << 29;
const int maxn = 18;
const int maxt = 66000;
struct P
{
    int x,y;
}po[maxn];
int map[maxn][maxn],limit[maxn],sum[maxt],dis[maxt];
int dp[maxt],tsp[maxt][maxn];
int m,n,tot;

inline void in(int &a)
{
    char ch;
    while(ch = getchar(), ch < '0' || ch > '9');
    a = ch - '0';
    while(ch = getchar(), ch >= '0' && ch <= '9')
    {
        a = a * 10 + ch - '0';
    }
    return;
}

int bis(int val)
{
    int l = 0,r = 1001;
    while(l <= r)
    {
        int mid = (l + r) >> 1;
        if(mid * mid >= val) r = mid - 1;
        else l = mid + 1;
    }
    return l;
}

int calc(int st)
{
    int res = 0;
    for(int i=0;i<n;i++)
    {
        if(st & (1 << i))
        {
            res += limit[i];
        }
    }
    return res;
}

void read()
{
    tot = 1 << n;
    for(int i=0;i<n;i++)
    {
        in(po[i].x),in(po[i].y);
    }
    for(int i=0;i<n;i++)
    {
        map[i][i] = 0;
        for(int j=i+1;j<n;j++)
        {
            map[i][j] = map[j][i] = bis(sqr(po[i].x - po[j].x) + sqr(po[i].y - po[j].y));
        }
    }
    for(int i=0;i<n;i++)
    {
        in(limit[i]);
    }
    for(int i=0;i<tot;i++)
    {
        sum[i] = calc(i);
    }
    return;
}

int judge()
{
    dp[0] = 0;
    for(int i=1;i<tot;i++)
    {
        dp[i] = inf;
        for(int j=i;j>0;j = (j - 1) & i)  //枚举子集
        {
            if(sum[j] <= m)
            {
                dp[i] = MIN(dp[i] , dp[i ^ j] + 1);
            }
        }
    }
    return dp[tot-1];
}

int walk()
{
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<tot;j++)
        {
            tsp[j][i] = inf;
        }
        tsp[1 << i][i] = map[0][i];
    }
    tsp[0][0] = 0;
    for(int i=1;i<tot;i++)
    {
        dis[i] = inf;
        if(sum[i] > m) continue;
        for(int j=0;j<n;j++)
        {
            if((i & (1 << j)) == 0) continue;
            int st = i ^ (1 << j);
            for(int k=0;k<n;k++)
            {
                if(st && ((st & (1 << k)) == 0 || tsp[st][k] == inf)) continue;
                tsp[i][j] = MIN(tsp[i][j] , tsp[st][k] + map[k][j]);
            }
            if(tsp[i][j] < inf)
            {
               dis[i] = MIN(dis[i] , tsp[i][j] + map[j][0]);
            }
        }
    }
    dp[0] = 0;
    for(int i=1;i<tot;i++)
    {
        dp[i] = inf;
        for(int j=i;j>0;j = (j - 1) & i)
        {
            if(dis[j] < inf)
            {
                dp[i] = MIN(dp[i] , dp[i ^ j] + dis[j]);
            }
        }
    }
    return dp[tot-1];
}

void solve()
{
    int cnt = judge();
    if(cnt == inf)
    {
        puts("-1 -1");
        return;
    }
    int res = walk();
    printf("%d %d\n",cnt,res);
    return;
}

int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        read();
        solve();
    }
    return 0;
}