Good Firewall(字典树 HDU4760)

Good Firewall

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 713 Accepted Submission(s): 203

Problem Description

Professor X is an expert in network security. These days, X is planning to build a powerful network firewall, which is called Good Firewall (a.k.a., GFW). Network flows enter in the GFW will be forwarded or dropped according to pre-established forwarding policies.

Basically, a forwarding policy P is a list of IP subnets, {ip_subnet_1, …, ip_subnet_n}. If P is enabled in GFW, a network flow F with source and destination IP address both located in P can be accepted and forwarded by GFW, otherwise F will be dropped by GFW.

You may know that, an IP address is a 32-bit identifier in the Internet, and can be written as four 0~255 decimals. For example, IP address 01111011.00101101.00000110.01001110 can be expressed as 123.45.6.78. An IP subnet is a block of adjacent IP address with the same binary prefix, and can be written as the first IP address in its address block together with the length of common bit prefix. For example, IP subnet 01111011.00101101.00000100.00000000/22 (123.45.4.0/22) is an IP subnet containing 1024 IP addresses, starting from 123.45.4.0 to 123.45.7.255. If an IP address is in the range of an IP subnet, we say that the IP address is located in the IP subnet. And if an IP address is located in any IP subnet(s) in a policy P, we say that the IP address is located in the policy P.

How will you design the GFW, if you take charge of the plan?

Input

The input file contains no more than 32768 lines. Each line is in one of the following three formats:

E id n ip_subnet_1 ip_subnet_2 … ip_subnet_n

D id

F ip_src ip_dst

The first line means that a network policy Pid (1<=id<=1024) is enabled in GFW, and there are n (1<=n <=15) IP subnets in Pid. The second line means that policy Pid (which is already enabled at least once) is disabled in GFW. The last line means that a network flow with source and destination IP address is entered in GFW, and you need to figure out whether GFW is going to forward (F) or drop (D) this flow:

1. If the source and destination IP address both are located in one of enabled policy group Pid, GFW will forward this flow.

2. Otherwise GFW will drop this flow. That is, if the source or destination IP address is not located in any of enabled policy group, or they are only located in different enabled policy group(s), GFW will drop it.

IP subnets can be overlapped. An IP address may or may not be located in any policy group, and can also be located in multiple policy groups.

In the global routing table, most of the IP subnets have at least 2^8 IP addresses, and at most 2^24 IP addresses. In our dataset, every IP subnet has a prefix length between 8 and 24.

Output

For each ‘F’ operation, output a single ‘F’ (forward) or ‘D’ (drop) in a single line. Just see the sample output for more detail.

Sample Input

E 1 2 123.45.4.0/22 123.45.8.0/22

F 123.45.4.1 123.45.8.1

F 123.45.8.1 123.45.4.1

E 2 1 123.45.6.0/24

D 1

F 123.45.6.123 123.45.6.234

F 123.45.8.1 123.45.4.1

Sample Output

F

F

F

D

字典树的好题

题目大意：有一个防火墙，具有添加一个子网络，删除一个子网络，以及转发包的操作。

添加操作包含子网络的id，以及子网络的子网掩码（计算出网络前缀，以及ip的下限），不会超过15个。

删除则是给定要删除的子网络id。

转发操作，给定两个ip，如果两个ip在同一个子网络中，则可以转发，否则丢弃。

解题思路：对子网掩码前缀建立字典树，每个前缀终止节点用一个set记录属于哪些子网络，ip下限。那么增加和删除操作既可以解决了。对于查询操作，分别查询两个ip，处理除两个ip可能属于的网络，判断有无共同即可。

#include <map>
#include <set>
#include <queue>
#include <cstring>
#include <string>
#include <cstdio>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

struct Trie
{
    int next[2];
    vector<int>vec;
} st[1024*15*32+1000];

int top;

struct IP
{
    int n;
    LL res[20];
    int len[20];
} sub[1200];

LL bite[40];

char str[110];

int Creat()
{
    memset(st[top].next,-1,sizeof(st[top].next));
    st[top].vec.resize(0);
    return top++;
}

void Insert(int Root,int len,int id, LL res)
{
    for(int i=1; i<=len; i++)
    {
        int ans=(bite[32-i]&res)?1:0;

        if(st[Root].next[ans]==-1)
        {
            st[Root].next[ans]=Creat();
        }

        Root=st[Root].next[ans];
    }

    st[Root].vec.push_back(id);
}

void Delete(int id,int len,LL res,int Root)
{
    for(int i=1; i<=len; i++)
    {
        Root=st[Root].next[(res&bite[32-i])?1:0];
    }
    for(vector<int>::iterator it=st[Root].vec.begin(); it!=st[Root].vec.end(); it++)
    {
        if(*it==id)
        {
            *it=0;

            break;
        }
    }
}

bool vis[1050];

bool Query(LL res,int num,int Root)
{
    vector<int>::iterator it;
    for(int i=1; i<=32; i++)
    {
        for(it = st[Root].vec.begin(); it!=st[Root].vec.end(); it++)
        {
            if(*it == 0)
            {
                continue;
            }
            if(num==1)
            {
                vis[*it] = true;
            }
            else
            {
                if(vis[*it])
                {
                    return true;
                }
            }
        }

        int ans=(bite[32-i]&res)?1:0;

        if(st[Root].next[ans]==-1)
        {
            return false;
        }

        Root = st[Root].next[ans];
    }
    for(it=st[Root].vec.begin(); it != st[Root].vec.end(); it++)
    {
        if(*it==0)
        {
            continue;
        }

        if(num==1)
        {
            vis[*it]=true;
        }
        else
        {
            if(vis[*it])
            {
                return true;
            }
        }
    }
    return false;
}

int main()
{
    top=0;

    int a,b,c,d,len;

    int Root = Creat();

    char s[3];

    int id,n;

    bite[0]=1;

    for(int i=1; i<=40; i++)
    {
        bite[i]=bite[i-1]<<1;
    }

    while(~scanf("%s",s))
    {
        if(s[0]=='E')
        {
            scanf("%d %d",&id,&n);

            sub[id].n=n;

            for(int i=1; i<=n; i++)
            {
                scanf("%s",str);

                sscanf(str,"%d.%d.%d.%d/%d",&a,&b,&c,&d,&len);

                LL res = a*256LL*256LL*256LL+b*256LL*256LL+c*256LL+d;

                sub[id].res[i]=res;

                sub[id].len[i]=len;

                Insert(Root,len,id,res);
            }

        }
        else if(s[0]=='D')
        {
            scanf("%d",&id);

            for(int i=1; i<=sub[id].n; i++)
            {
                Delete(id,sub[id].len[i],sub[id].res[i],Root);
            }
        }

        else if(s[0]=='F')
        {
            scanf("%s",str);

            sscanf(str,"%d.%d.%d.%d",&a,&b,&c,&d);

            memset(vis,false,sizeof(vis));

            Query(a*256LL*256LL*256LL+b*256LL*256LL+c*256LL+d,1,Root);

            scanf("%s",str);

            sscanf(str,"%d.%d.%d.%d",&a,&b,&c,&d);

            if(Query(a*256LL*256LL*256LL+b*256LL*256LL+c*256LL+d,2,Root))
            {
                printf("F\n");
            }
            else
            {
                printf("D\n");
            }
        }
    }
    return 0;
}