bzoj2310 ParkII

2310: ParkII

Time Limit: 20 Sec  Memory Limit: 128 MB
Submit: 273  Solved: 104
[Submit][Status][Discuss]

Description

Hnoi2007-Day1有一道题目 Park:给你一个 m * n 的矩阵,每个矩阵内有个
权值V(i,j) (可能为负数),要求找一条回路,使得每个点最多经过一次,并且经过
的点权值之和最大,想必大家印象深刻吧. 
无聊的小 C 同学把这个问题稍微改了一下:要求找一条路径,使得每个点
最多经过一次,并且点权值之和最大,如果你跟小 C 一样无聊,就麻烦做一下
这个题目吧.

Input

第一行 m, n,接下来 m行每行 n 个数即
V( i,j)

Output

一个整数表示路径的最大权值之和.

Sample Input

2 3
1 -2 1
1 1 1

Sample Output

5
【数据范围】
30%的数据,n≤6.
100%的数据,m<=100,n≤8.
注意:路径上有可能只有一个点.
分析:在bzoj1187的基础上将回路改成了路径. 那么需要多定义一种插头:独立插头.  分16种情况讨论......我参考了:传送门的题解.
   怎么样不遗漏地讨论这些情况呢?分为三类:1.下插头和右插头都不存在 2.下插头和右插头有一个存在 3.下插头和右插头都存在.
对于回路的讨论在这道题里都是对的,只是要新增对独立插头的讨论.
   重点考虑独立插头的产生与何时统计答案.独立插头在什么情况下可能产生呢?
   1.在下插头和右插头都不存在的情况下,那么下插头和右插头任意一个都可以当作独立插头.
   2.只存在一个插头的情况下,并且这个插头不是独立插头.可以不延伸这个插头,将它作为路径的一端,那么与它匹配的另一个插头就变成了独立插头.
   3.如果两个插头都存在,并且一个插头是独立插头. 把它们连接起来后,与这个不是独立插头的插头匹配的插头就变成了独立插头,因为没有插头与它匹配了.
   那么什么时候统计答案?
   1.下插头和右插头只有一个插头并且这个插头是独立插头的时候. 对于这个插头,它可以向两个方向延伸,每一次延伸实际上就是更新路径.那么就可以更新答案, 为了确保形成的确实是一条路径,在更新答案前要先判断状态是否为0.
   2.两个独立插头合并的时候.  可以看作是两个独立插头延伸碰到一起了. 也是要先判断一下状态是否为0.
   可以看出,什么时候统计答案取决于什么时候可能形成一条路径.
   要想做出这道题一定要理解清楚独立插头的概念,它是没有与之相匹配的插头.不允许去查找相匹配的插头.
   一个注意点:排除形成回路的情况!
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int inf = 0x7ffffff,maxn = 30010;
int n,m,a[110][110],ans = -inf,pow[10],now,pre;

struct node
{
    int head[maxn],nextt[maxn],sum[maxn],sta[maxn],tot;
    void clear()
    {
        memset(head,-1,sizeof(head));
        tot = 0;
        memset(sum,128/3,sizeof(sum));
        memset(sta,0,sizeof(sta));
    }
    void push(int x,int v)
    {
        int hashh = x % 10001;
        for (int i = head[hashh]; i >= 0; i = nextt[i])
        {
            if (sta[i] == x)
            {
                sum[i] = max(sum[i],v);
                return;
            }
        }
        sum[tot] = v;
        sta[tot] = x;
        nextt[tot] = head[hashh];
        head[hashh] = tot++;
    }
} f[2];

int turnleft(int x,int pos)
{
    return x << pow[pos];
}

int get(int x,int pos)
{
    return (x >> pow[pos]) & 3;
}

int del(int x,int i,int j)
{
    return x & (~(3 << pow[i])) & (~(3 << pow[j]));
}

int findr(int x,int pos)
{
    int cnt = 1;
    for (int i = pos + 1; i <= m; i++)
    {
        int temp = get(x,i);
        if (temp == 1)
            cnt++;
        else if (temp == 2)
            cnt--;
        if (cnt == 0)
            return i;
    }
}

int findl(int x,int pos)
{
    int cnt = 1;
    for (int i = pos - 1; i >= 0; i--)
    {
        int temp = get(x,i);
        if (temp == 2)
            cnt++;
        else if (temp == 1)
            cnt--;
        if (cnt == 0)
            return i;
    }
}

void solve2(int x,int y,int k)
{
    int p = get(f[pre].sta[k],y - 1);
    int q = get(f[pre].sta[k],y);
    int staa = del(f[pre].sta[k],y - 1,y);
    int v = f[pre].sum[k];
    if (staa > (1 << pow[m + 1]))
        return;
    if (!p && !q)
    {
        f[now].push(staa,v);
        f[now].push(staa | turnleft(1,y - 1) | turnleft(2,y),v + a[x][y]);
        f[now].push(staa | turnleft(3,y - 1),v + a[x][y]);
        f[now].push(staa | turnleft(3,y),v + a[x][y]);
    }
    else if (!p)
    {
        int temp = p + q;
        if (q != 3)
        {
            f[now].push(staa | turnleft(temp,y),v + a[x][y]);
            f[now].push(staa | turnleft(temp,y - 1),v + a[x][y]);
            if (q == 1)
                f[now].push(staa ^ turnleft(temp,findr(staa,y)),v + a[x][y]);
            else
                f[now].push(staa ^ turnleft(temp,findl(staa,y)),v + a[x][y]);
        }
        else
        {
            f[now].push(staa | turnleft(temp,y),v + a[x][y]);
            f[now].push(staa | turnleft(temp,y - 1),v + a[x][y]);
            if (staa == 0)
                ans = max(ans,v + a[x][y]);
        }
    }
    else if (!q)
    {
        int temp = p + q;
        if (p != 3)
        {
            f[now].push(staa | turnleft(temp,y - 1),v + a[x][y]);
            f[now].push(staa | turnleft(temp,y),v + a[x][y]);
            if (p == 1)
                f[now].push(staa ^ turnleft(temp,findr(staa,y - 1)),v + a[x][y]);
            else
                f[now].push(staa ^ turnleft(temp,findl(staa,y - 1)),v + a[x][y]);
        }
        else
        {
            f[now].push(staa | turnleft(temp,y - 1),v + a[x][y]);
            f[now].push(staa | turnleft(temp,y),v + a[x][y]);
            if (staa == 0)
                ans = max(ans,v + a[x][y]);
        }
    }
    else if (p == 1 && q == 1)
        f[now].push(staa ^ turnleft(3,findr(staa,y)),v + a[x][y]);
    else if (p == 2 && q == 2)
        f[now].push(staa ^ turnleft(3,findl(staa,y - 1)),v + a[x][y]);
    else if (p == 2 && q == 1)
        f[now].push(staa,v + a[x][y]);
    else if (p == 3 && q == 1)
        f[now].push(staa ^ turnleft(1,findr(staa,y)),v + a[x][y]);
    else if (p == 3 && q == 2)
        f[now].push(staa ^ turnleft(2,findl(staa,y)),v + a[x][y]);
    else if (p == 1 && q == 3)
        f[now].push(staa ^ turnleft(1,findr(staa,y - 1)),v + a[x][y]);
    else if (p == 2 && q == 3)
        f[now].push(staa ^ turnleft(2,findl(staa,y - 1)),v + a[x][y]);
    else if (p == 3 && q == 3)
        if (staa == 0)
            ans = max(ans,v + a[x][y]);
}

void solve()
{
    now = 0,pre = 1;
    f[0].clear();
    f[0].push(0,0);
    for (int i = 1; i <= n; i++)
    {
        pre = now;
        now ^= 1;
        f[now].clear();
        for (int k = 0; k < f[pre].tot; k++)
            f[now].push(turnleft(f[pre].sta[k],1),f[pre].sum[k]);
        for (int j = 1; j <= m; j++)
        {
            pre = now;
            now ^= 1;
            f[now].clear();
            for (int k = 0; k < f[pre].tot; k++)
                solve2(i,j,k);
        }
    }
}

int main()
{
    for (int i = 1; i < 10; i++)
        pow[i] = i * 2;
    scanf("%d%d",&n,&m);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
        {
            scanf("%d",&a[i][j]);
            ans = max(ans,a[i][j]);
        }
    solve();
    printf("%d\n",ans);

    return 0;
}

 

 
posted @ 2018-02-22 16:18  zbtrs  阅读(159)  评论(0编辑  收藏  举报