牛客网暑期ACM多校训练营（第一场）菜鸟补题QAQ

　　签到题 J Different Integers（树状数组）

　　题目大意：给一个长为n的数组，每一个询问给两个数字i, j ，询问1~i, j~n这两个区间中有多少不同的数字，真的像是莫队裸题，但是两个区间是分隔的，所以可以考虑将数组延长一倍，即num[i] = num[i+n]，这样就可以变成一段区间中查询了，不过这样会T.....参考了题解的做法还是比较好用的,写法非常巧妙。记录数字i第一次和最后一次出现的位置分别为first[i], last[i]，按每个询问的rhs从小到大排序后，遍历num数组。遍历序号为i，每次遍历处理询问和维护一个树状数组，①只有当某个询问的 rhs == i 时处理该询问②维护树状数组，首先我们可以想到假如某个数x，当last[x] == i 时，下个遍历时下个询问的rhs必然会大于这个last[x]（因为是从1~n遍历），所以当这次遍历过后，剩下的询问rhs全部大于last[x]，所有右边区间rhs~n已经没有x了，这个时候只要看前面lhs是不是小于first[x]就知道这个数在不在询问区间了，这个时候就可以维护一个前缀和，sum[i]表示表示有多少个数的first值是在1~i内的。

 #include <iostream>
 #include <string.h>
 #include <cstdio>
 #include <vector>
 #include <map>
 #include <string>
 #include <algorithm>
 #include <time.h>

 #define SIGMA_SIZE 26
 #define lson rt<<1
 #define rson rt<<1|1
 #define  lowbit(x) (x&-x)
 #pragma warning ( disable : 4996 )

 using namespace std;
 typedef long long LL;
 inline LL LMax(LL a,LL b)      { return a>b?a:b; }
 inline LL LMin(LL a,LL b)      { return a>b?b:a; }
 inline int Max(int a,int b)    { return a>b?a:b; }
 inline int Min(int a,int b)    { return a>b?b:a; }
 inline int gcd( int a, int b ) { return b==?a:gcd(b,a%b); }
 inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
 const LL INF = 0x3f3f3f3f3f3f3f3f;
 const LL mod  = ;
 const double eps = 1e-;
 const int inf  = 0x3f3f3f3f;
 const int maxk = 1e4+;
 const int maxn = 1e5+;

 int n, q, tot;
 int first[maxn], last[maxn];
 int num[maxn], ans[maxn], _count[maxn];

 struct node {
     int lhs, rhs, id;
 }p[maxn];

 void add( int x, int d )
 {
     while ( x >  )
     {
         _count[x] += d;
         x -= lowbit(x);
     }
 }

 int sum(int x)
 {
     int s = ;
     while ( x <= n )
     {
         s += _count[x];
         x += lowbit(x);
     }
     return s;
 }

 bool cmp(const node& a, const node &b)
 { return a.rhs < b.rhs; }

 void init()
 {
     tot = ;
     memset(first, -, sizeof(first));
     memset(last, -, sizeof(last));
     memset(_count, , sizeof(_count));

     for (int i = ; i <= n; i++)
     {
         scanf("%d", &num[i]);
         if (first[num[i]] == -)
             { tot++; first[num[i]] = i;}
         last[num[i]] = i;
     }

     for (int i = ; i <= q; i++)
     {
         scanf("%d %d", &p[i].lhs, &p[i].rhs);
         p[i].id = i;
     }
     sort(p+, p++q, cmp);
 }

 int main()
 {
     while (~scanf("%d %d", &n, &q))
     {
         init();

         for (int i = , k = ; i <= n; i++)
         {   //如果有边界到达了某一点i，则可以开始处理左边界
             while (k <= q && p[k].rhs == i)
             {
                 ans[p[k].id] = tot - sum(p[k].lhs);
                 k++;
             }

             if (last[num[i]] == i)
                 add(first[num[i]]-, );
         }

         for ( int i = ; i <= q; i++ )
             printf("%d\n", ans[i]);
     }

     return ;
 }

　　

　　签到题？ D Two Graphs

　　题目大意：给两个简单图G1(V, E1), G2(V,E2) ,问有多少个G2的子图与G1是同构的，想了好多骚操作，，结果hash去重就可以了

 #include <iostream>
 #include <string.h>
 #include <cstdio>
 #include <vector>
 #include <set>
 #include <string>
 #include <algorithm>
 #include <time.h>

 #define SIGMA_SIZE 26
 #define lson rt<<1
 #define rson rt<<1|1
 #define  lowbit(x) (x&-x)
 #pragma warning ( disable : 4996 )

 using namespace std;
 typedef long long LL;
 inline LL LMax(LL a,LL b)      { return a>b?a:b; }
 inline LL LMin(LL a,LL b)      { return a>b?b:a; }
 inline int Max(int a,int b)    { return a>b?a:b; }
 inline int Min(int a,int b)    { return a>b?b:a; }
 inline int gcd( int a, int b ) { return b==?a:gcd(b,a%b); }
 inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
 const LL INF = 0x3f3f3f3f3f3f3f3f;
 const LL mod  = ;
 const double eps = 1e-;
 const int inf  = 0x3f3f3f3f;
 const int maxk = 1e4+;
 const int maxn = 1e5+;

 struct edge2 {
     int x, y;
 }edge[];
 int v, e1, e2;
 int g1[][], g2[][], num[];

 void init()
 {
     memset(g1, , sizeof(g1));
     memset(g2, , sizeof(g2));
     for ( int i = ; i <= v; i++ )
         num[i] = i;

     int x, y;
     for ( int i = ; i <= e1; i++ )
         { scanf("%d %d", &x, &y); g1[x][y] = ; g1[y][x] = ; }
     for ( int i = ; i <= e2; i++ )
     {
         scanf("%d %d", &x, &y);  g2[x][y] = ; g2[y][x] = ;
         edge[i].x = x;
         edge[i].y = y;
     }

 }

 int main()
 {
     while (~scanf("%d %d %d", &v, &e1, &e2))
     {
         init();

         set<long long> ss;
         do {
             int cnt = ;
             long long has = ;
             for (int i = ; i <= e2; i++)
             {
                 if (g1[num[edge[i].x]][num[edge[i].y]])
                 {
                     has = has* + i;
                     has %= mod;
                     cnt++;
                 }
             }

             if (cnt == e1)
                 ss.insert(has);

         }while(next_permutation(num+, num++v));

         printf("%zd\n", ss.size());
     }

     return ;
 }