NWU现场赛——解题报告

负二进制转换

Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Problem Description

QAQ学长对于现在大家普遍学习的C语言、Java语言等等很是不屑，他认为二进制指令才是最优美的语言;苦苦思考哲学的QAQ学长
已经不满足正二进制了，他现在研究的是负二进制，他给你一串负二进制表示的编码，希望你告诉他这串负二进制表示的十进制数是
多少。

Input

Output

Sample Input

1011
001101001

Sample Output

-3
220

Hint:
对于第一组样例
ans = 1*(-2)^0 + 0*(-2)^1 + 1*(-2)^2 + 1*(-2)^3 = -3

水题，直接签到。

 #include <bits/stdc++.h>

 using namespace std;

 int b[];
 char s[];

 int main(){

     b[] = ;
     for (int i = ; i <= ; ++i) b[i] = b[i - ] * (-);

     while (~scanf("%s", s)){
         int ans = ;
         for (int i = ; i < strlen(s); ++i)
             ans += ((int)s[i] - ) * b[i];

         printf("%d\n", ans);
     }

     return ;

 }

反序数

Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Problem Description

计算数X的反序数（百度百科：所谓反序数，即有这样成对的数，其特点是其中一个数的个数字排列顺序完全颠倒过来，就变成另一个数）。

Input

多组输入，每组输入占一行，表示一个数X。

Output

对于每组输入，在一行内输出其反序数，每组输出之间留一个空行。

Sample Input

123
321
123456879123

Sample Output

321

123

321987654321

同样，水题。

 #include <bits/stdc++.h>

 using namespace std;

 char s[];

 int main(){

     while (~scanf("%s", s)){
         for (int i = strlen(s) - ; i >= ; --i) putchar(s[i]);
         printf("\n\n");
     }

     return ;

 }

 

翻转区间

Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Problem Description

Yimi学长非常喜欢翻牌子，但是如今Yimi学长已经不能满足于翻牌子了，他在新研究怎样翻转一个区间。于是他的哥哥Jstyle就来帮助他解决这个难题了，Jstyle规定了一种翻转区间的新规则。
  1> 若已知某区间长度为n, 区间编号 i 从 1-n, ai表示标号为i的元素。
  2> Jstyle从i = 1开始翻转 [i, n-i+1]这个区间，i <= n-i+1 的时候，他会一直翻转下去。
  Jstyle现在给他的弟弟出难题了，他给Yimi一个翻转后的区间，让Yimi求出翻转前的区间是什么。Yimi最近有点ZZ，他希望善良的你帮他解决这个问题。

Input

多组输入，每组输入如下
第一行输入一个整数 n, (1 <= n <= 200000);
第二行输入n个整数 a1, a2, ..., an (-10^9 <= ai <= 10^9)表示翻转后区间内的元素;

Output

多组输出，每组输出n个整数，用空格隔开，表示翻转前的区间元素。（注意最后一个数字后面没有空格）;

Sample Input

7
4 3 7 6 9 1 2
8
6 1 4 2 5 6 9 2

Sample Output

2 3 9 6 7 1 4
2 1 6 2 5 4 9 6

Hint
对于第一组样例：
第0步操作后，区间为 2 3 9 6 7 1 4
第1步操作翻转[1, 7], 区间为 4 1 7 6 9 3 2
第2步操作翻转[2, 6], 区间为 4 3 9 6 7 1 2
第3步操作翻转[3, 5], 区间为 4 3 7 6 9 1 2
第4步操作翻转[4, 4], 区间为 4 3 9 6 7 1 2
结束操作。

 思想比较简单，判一下奇偶就可以了。

 #include <bits/stdc++.h>

 using namespace std;

 #define REP(i,n)                for(int i(0); i <  (n); ++i)
 #define rep(i,a,b)              for(int i(a); i <= (b); ++i)
 #define dec(i,a,b)              for(int i(a); i >= (b); --i)
 #define for_edge(i,x)           for(int i = H[x]; i; i = X[i])

 const int N     =          +       ;

 int a[N], l, n, cnt;

 int main(){

     while (~scanf("%d", &n)){
         rep(i, , n) scanf("%d", a + i);
         l = n / ; cnt = ;
         rep(i, , l){
             ++cnt;
             if (cnt & ) swap(a[i], a[n - i + ]);
         }
         rep(i, , n - ) printf("%d ", a[i]); printf("%d\n", a[n]);
     }

     return ;

 }

养兔兔

Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Problem Description

ZKY学长是远近闻名的养兔大户，凭借特殊的养兔技巧能够稳定地控制兔子的繁殖周期：对于每一只新生兔，出生后第六年开始每年年初都会产一只兔崽。
最近，寂寞的ZKY学长又从黑市进了一只新生兔，并使用自己的调教方式对其进行改造。
ZKY学长想要看看以自己的手艺，在第X年能够繁殖到多少只兔子。可惜ZKY学长数学不是很好，所以只能求助于聪明的同学们了。
（从第一年算起，第一年有一只兔子）

Input

多组输入，每组输入占一行，表示第X年。(1<=X<=54)

Output

对于每组输入，在一行内输出该年兔子数。

Sample Input

1
6
8
13

Sample Output

1
2
4
15

递推式f(n)=f(n-1)+f(n-5)

因为n<=54，那么答案用long long存就可以了。

 #include <bits/stdc++.h>

 using namespace std;

 long long f[];

 int main(){

     for (int i = ; i <= ; ++i) f[i] = ;
     for (int i = ; i <= ; ++i) f[i] = f[i - ] + f[i - ];

     int n;
     while (~scanf("%d", &n)) printf("%lld\n", f[n]);

     return ;

 }

Beautiful String

Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Problem Description

ACM竞赛围绕字符串的题目数不胜数，这不又来一个字符串的题目需要你去解决。已知：
第0个字符串：U
第1个字符串：DU
第2个字符串：UDDU
第3个字符串：DUUDUDDU
第4个字符串：UDDUDUUDDUUDUDDU
......
相信你已经发现规律了，没错！就是第i个字符串 = 第i-1个字符串的取反 + 第i-1个字符串;取反(U->D, D->U);
现在告诉你n和k，让你求得第n个字符串的第k个字符是多少。(注意字符串编号从0开始);

Input

多组输入，每组输入两个数字n, k;(0 <= n <= 51, 0 <= k < 2^n);

Output

输出up或者down表示所求字符是 U或者D;

Sample Input

3 6
51 123456789012345

Sample Output

down
up

分类讨论当前所求字符在字符串的前一半还是后一半，算出要改变多少次cnt。
那么最后看cnt的奇偶性即可。

 #include <bits/stdc++.h>

 using namespace std;

 long long b[];
 int n;
 long long l;

 int main(){

     b[] = ; for (int i = ; i <= ; ++i) b[i] = b[i - ] * ;
     while (~scanf("%d%lld", &n, &l)){
         ++l;
         int cnt = ;
         for (; n; --n) if (l > b[n - ]) l -= b[n - ]; else ++cnt;
         puts(cnt %  ? "down" : "up");
     }

     return ;

 }

 

神奇的花瓣

Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Problem Description

ZZC学长很具有科研精神，他来自遥远的内蒙古草原，对西安的很多事物都十分好奇。
今天，他又在宿舍一楼阳台下的阴暗角落里发现了一种奇异的花。这种花由六瓣组成，每瓣形状各异。
ZZC学长统计出花瓣共有六种形状，并为这些形状编号。他找到了N朵花，以顺时针方向对每朵花进行观察，但是他的数学跟ZKY学长一样不是很好，你能帮他统计一共有多少朵形状不同的花么？
（hint:123456和612345是一种形状的花）

Input

多组输入，每组第一行数字N，第二行开始N行每行六个数字表示一朵花的形状。（1<=N<=1000000）

Output

对于每组输入，在单独的一行输出一个数，表示多少种形状不同的花。

Sample Input

2
123456
612345
3
135555
124444
355551

Sample Output

1
2

本来想着用字符串的最小表示法做这道题……结果还是写了暴力（因为字符串长度为6）

 #include <bits/stdc++.h>

 using namespace std;

 #define rep(i, a, b) for (int i(a); i <= (b); ++i)

 string cs[];

 char s[];
 int n;

 set <string> mp;

 int main(){

     while (~scanf("%d", &n)){
         mp.clear();
         for (int i = ; i <= n; ++i){
             scanf("%s", s);
             rep(j, , ) cs[j] = "";
             int t = ;
             rep(j, , ){
                 ++t;
                 rep(k, j, ) cs[t] += s[k];
                 rep(k, , j - ) cs[t] += s[k];
             }

             string ssc = cs[];
             rep(j, , ) if (ssc > cs[j]) ssc = cs[j];

             mp.insert(ssc);

         }

         printf("%d\n", (int)mp.size());

     }

     return ;

 }

景女神与她的托福

Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Problem Description

景女神最近一直在恶补英语，她要为了她的托福做准备。于是，满神给景女神出了一道题，来帮助景女神学习英语。
  满神给了景女神一个长度为n的字符串，字符串只包含小写字母 a,b;并且告诉景女神她最多可以改变k个字符(a->b, b->a);满神想知道经过不超过k次的改变后，出现相同字母的字符串(连续)的最大长度是多少。
  景女神觉得这个题和她记单词并没有什么关系，于是就学英语去了。但是满神希望聪明的你可以帮助他解决这个问题。

Input

多组输入，每组输入如下
第一行输入两个整数n和k，用空格隔开 (1 <= n <= 100000, 0 <= k <= n);
第二行输入一个字符串。(只包含小写字母 a和b);

Output

多组输出，每组输出一个整数，表示经过不超过k次改变后，出现相同字符的最大字符串长度。

Sample Input

4 2
abba
8 1
aabaabaa

Sample Output

4
5

Hint:
第一组样例：可以得到 aaaa 或者 bbbb;最大长度为4;
第二组样例：可以得到 aaaaabaa 或者 aabaaaaa; 最大长度的字符串是 aaaaa，长度为5;

首先我们不难发现如果要修改字母，只可能进行一种修改，也就是说：
修改操作都是把a改成b，或者都把b改成a
不可能有些操作是把a改成b，有些操作是把b改成a。
维护两个前缀，f[i]表示字符串的第1位带第i位中有几个a，
            c[i]表示字符串的第1位到第i为中有几个b。（假设字符串从1开始标号）
那么现在考虑第i位，确定以s[i]为右端点，用上k次（或少于k次）的修改机会，能得到的相同字母的字符串
最左能延伸到哪里。
因为前缀都是单调递增的，那么二分就可以了。
两种字母都考虑一遍，同时更新答案。

 #include <bits/stdc++.h>

 using namespace std;

 #define rep(i, a, b)              for(int i(a); i <= (b); ++i)

 const int N =  + ;

 char s[N];
 int a[N], c[N], f[N];
 int n, k, l, r, cnt, ans;

 int main(){

     while (~scanf("%d%d%s", &n, &k, s + )){
         rep(i, , n) a[i] = s[i] == 'a' ?  : ;
         memset(c, , sizeof c);
         memset(f, , sizeof f);
         rep(i, , n) if (a[i] == )  c[i] = c[i - ] + ; else c[i] = c[i - ];
         rep(i, , n) if (a[i] == )  f[i] = f[i - ] + ; else f[i] = f[i - ];
         ans = ;
         rep(i, , n){
             l = , r = i;
             if (l == r) cnt = l;
             else{
                 while (l +  < r){
                     int mid = (l + r) / ;
                     if (c[i] - c[mid - ] <= k) r = mid; else l = mid + ;
                 }

                 if (c[i] - c[l - ] <= k) cnt = l; else cnt = r;
             }
             ans = max(ans, i - cnt + );
             l = , r = i;
             if (l == r) cnt = l;
             else{
                 while (l +  < r){
                     int mid = (l + r) / ;
                     if (f[i] - f[mid - ] <= k) r = mid; else l = mid + ;
                 }

                 if (f[i] - f[l - ] <= k) cnt = l; else cnt = r;
             }
             ans = max(ans, i - cnt + );
         }

         printf("%d\n", ans);
     }

     return ;

 }

Poor ZKY

Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Problem Description

ZKY学长老家的正方形兔子窝群着火了，火势每天向上下左右四个方向蔓延一个窝。
ZKY学长只知道最初的火情，当他赶到家时已经是第X天了，他想知道现在的状况。

Input

多组输入样例，每组第一行两个数字N和X，接下来一组N*N的符号表示初始兔子窝群，.是未着火的窝，*表示已着火的窝。
每组样例以一个空行隔开。(1<=N<=10,0<=X<=10)

Output

当前兔子窝群状况，每组输出后留一个空行。

Sample Input

3 2
...
...
.*.

4 1
....
.*..
....
....

Sample Output

.*.
***
***

.*..
***.
.*..
....

暴力模拟一下。

 #include <bits/stdc++.h>

 using namespace std;

 int a[][], b[][];
 char s[];
 int n, x;

 int main(){

     while (~scanf("%d%d", &n, &x)){
         for (int i = ; i <= n; ++i){
             scanf("%s", s + );
             for (int j = ; j <= n; ++j)
                 a[i][j] = s[j] == '.' ?  : ;
         }

         for (; x; x--){

             memcpy(b, a, sizeof a);
             for (int i = ; i <= n; ++i)
                 for (int j = ; j <= n; ++j) if (a[i][j]){
                     b[i - ][j] = b[i + ][j] = b[i][j - ] = b[i][j + ] = ;
                 }

             memcpy(a, b, sizeof b);
         }

         for (int i = ; i <= n; ++i){
             for (int j = ; j <= n; ++j) putchar(((a[i][j]) ? '*' : '.'));
             putchar();

         }
         putchar();
     }

     return ;

 }

素数迭代

Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Problem Description

定义函数f(i)为i的所有素因子和。
定义g(i)为f(i)的迭代次数，(迭代即f(f(f(...f(i)))))，迭代次数至少为1。
当i为素数(即f(i) = i)的时候停止迭代。
现在给定三个数l, r, p，求[l, r]区间内有多少个数x满足g(x) = p;

Input

多组输入，每组输入三个数，分别代表l, r, p; (2 <= l <= r <= 1000000, 1 <= p <= 1000000)

Output

每组输出一行，根据题意输出一个满足条件的数字;

Sample Input

90 90 3
2 9 1
2 9 2
800 810 4
999999 1000000 2
100000 1000000 1000000

Sample Output

1
4
4
5
2
0

Hint:
对于l = 2, r = 9, p = 2这组数据，根据题意得;
f(2) = 2;
f(3) = 3;
f(4) = 2;
f(5) = 5;
f(6) = 2+3 = 5;
f(7) = 7;
f(8) = 2;
f(9) = 3;
则迭代次数 g(i) = 2 的有g(4), g(6), g(8), g(9), 共有4个，因此输出4;

首先，用类似筛选素数的方法求出f(i)。
注意到每次迭代之后，原先的那个数是大幅度减小的，再最坏的情况下也会减小到原来的一半左右。
那么可以作出大胆的假设：g(i) <= 30 （1<=i<=1e6）事实上g(i) <= 12 （1<=i<=1e6）
那么暴力求g(i)就可以了。
接下来我们对询问离线操作。从1道12每次维护一个前缀，将对应的答案塞到询问中即可。
p大于12的询问不做处理，那么答案就是0。

 #include <bits/stdc++.h>

 using namespace std;

 #define rep(i, a, b) for (int i(a); i <= (b); ++i)

 struct query{
     int l, r, num, ans, id;
     friend bool operator < (const query &a, const query &b){
         return a.num < b.num;
     }
 } q[];

 int p[];
 int n;
 int cnt;
 int prime[];
 int f[], g[];

 int ct[];

 bool cmp(const query &a, const query &b){
     return a.id < b.id;
 }

 int main(){

     memset(p, , sizeof p);
     rep(i, , ) if (!p[i]){
         for (int j = i + i; j <= ; j += i){
             p[j] = ;
         }
     }

     cnt = ;
     rep(i, , ) if (!p[i]) prime[++cnt] = i;

     memset(f, , sizeof f);
     rep(i, , cnt){
         for (int j = prime[i]; j <= ; j += prime[i]){
             f[j] += prime[i];
         }
     }

     memset(g, , sizeof g);
     rep(i, , ){
         int et = , now = i;
         while (now != f[now]){
             ++et;
             now = f[now];
         }

         g[i] = et;
     }

     int aa, bb, cc, n = ;
     while (~scanf("%d%d%d", &aa, &bb, &cc)){
         ++n;
         q[n].l = aa, q[n].r = bb, q[n].num = cc; q[n].id = n;
     }

     sort(q + , q + n + );
     rep(i, , ){
         memset(ct, , sizeof ct);
         rep(j, , ) if (g[j] == i) ct[j] = ct[j - ] + ; else ct[j] = ct[j - ];
         rep(j, , n){
             if (q[j].num == i) q[j].ans = ct[q[j].r] - ct[q[j].l - ];
         }
     }

     sort(q + , q + n + , cmp);
     rep(i, , n) printf("%d\n", q[i].ans);

 }

神秘的迷宫

Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Problem Description

ZZC学长因为发现了奇异的花朵被神秘组织绑架到了一个阴暗的迷宫，这个迷宫有四种暗门和最多一个出口，每个暗门都有一把钥匙与其对应，粗心的神秘组织成员把一些钥匙散落在迷宫内。
ZZC学长只有找到钥匙才能打开暗门，他醒来后找到一张也是粗心的神秘组织成员留下的地图。
因为刚刚醒来，ZZC学长一分钟之内只能向上下左右走一格，走路的同时，他也能拿起钥匙或者打开暗门，不会影响走路速度。
ZZC学长希望以最快的速度离开迷宫，聪明的同学能帮帮他么？

Input

多组输入，每组输入第一行两个数字N和M表示迷宫的行数和列数。之后N行，每行M个字符描述该迷宫：.表示可以行走的路，#表示出口，*表示迷宫的墙壁，0表示ZZC学长当前位置，
1、2、3、4分别表示每种暗门，5、6、7、8依次对应每种钥匙。(0 < N,M < 1000)

Output

对于每组输入，在一行内输出一个数字，表示离开迷宫的最短时间，若无法找到出口，则输出-1。

Sample Input

3 3
...
.0.
.#.

5 5
*.0.*
.1*5*
.**.*
...**
*#***

Sample Output

1
11

hint:第二个样例里，ZZC学长先用2分钟拿到钥匙5，再用4分钟打开暗门1，最后用5分钟走到出口。

比较基础的加条件BFS，只是这个数据范围可能会MLE……然后发现开100*100的数组就够了。

 #include <bits/stdc++.h>

 using namespace std;

 #define REP(i, n)                 for(int i(0); i <  (n); ++i)
 #define rep(i, a, b)              for(int i(a); i <= (b); ++i)
 #define dec(i, a, b)              for(int i(a); i >= (b); --i)
 #define for_edge(i, x)            for(int i = H[x]; i; i = X[i])

 #define LL      long long
 #define ULL     unsigned long long
 #define MP      make_pair
 #define PB      push_back
 #define FI      first
 #define SE      second
 #define INF     1 << 30

 const int N     =          +       ;
 const int M     =           +       ;
 const int Q     =            +       ;
 const int A     =              +       ;

 const int dx[] = {, , , -};
 const int dy[] = {, , -, };

 bool h[][][ <<];
 char a[][];
 int n, m;

 struct node{
     int x, y, key, st;
     bool check(){ return x >=  && x < n && y >=  && y < m && a[x][y] != '*';}
     bool door(){ return a[x][y] >= '' && a[x][y] <= '';}
     bool keyy(){ return a[x][y] >= '' && a[x][y] <= '';}
 } start, cur, nx;

 int BFS(){
     queue <node> q;
     while (!q.empty()) q.pop();
     memset(h, false, sizeof h);
     h[start.x][start.y][start.key] = true;
     q.push(start);

     while (!q.empty()){
         cur = q.front(); q.pop();
         if (a[cur.x][cur.y] == '#') return cur.st;
         REP(i, ){
             nx = cur; nx.x += dx[i], nx.y += dy[i], ++nx.st;
             if (nx.check()){
                 if (nx.door()){
                     int key = a[nx.x][nx.y] - '';
                     if (nx.key & ( << key) && !h[nx.x][nx.y][nx.key])
                         h[nx.x][nx.y][nx.key] = true, q.push(nx);
                 }
                 else
                 if (nx.keyy()){
                     int key =  << (a[nx.x][nx.y] - ''); nx.key |= key;
                     if (!h[nx.x][nx.y][nx.key]) h[nx.x][nx.y][nx.key] = true, q.push(nx);
                 }

                 else
                 if (!h[nx.x][nx.y][nx.key]) h[nx.x][nx.y][nx.key] = true, q.push(nx);
             }
         }
     }

     return -;
 }

 int main(){

     while (~scanf("%d%d", &n, &m)){
         REP(i, n){
             scanf("%s", a[i]);
             REP(j, m) if (a[i][j] == '') start.x = i, start.y = j, start.key = , start.st = ;
         }

         printf("%d\n", BFS());
     }

     return ;

 }

这是一道简单题

Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/102400K (Java/Other)

Problem Description

“三角形十分的美丽，相信大家小学就学过三角形具有稳定性，三角形也是二维几何中最基本的必不可少的元素之……”，满叔叔走在路上若有所思，突然抬头看到了天空中有很多很亮的星星划过，星星和他们划过的轨迹像极了一个无向图。于是好学的满叔叔，就开始数起了“三角形”，1、2、3……数了好久，满叔叔数的眼泪都掉下来了，所以他哭着请求你来帮他，数有多少个三角形，你这么好心一定不会拒绝吧！满叔叔的三角形的定义：如果存在这样的三个边(A,B)、(B,C)、(A,C)（无向边），则算一个三角形。
满叔叔会告诉你点数（星星个数）n和边数（轨迹个数）m以及每条边的两个点。

注意：两个三角形不同是：当对于两个三角形的边，某个三角形存在一条边在另一个三角形的边中无法找到！
保证数据没有重边和自环。

Input

多组数据。
第一行一个整数T<=10表示数据组数。
对于每组数据的第一行n表示星星个数，m表示星星划过的轨迹的个数，
接下来m行表示每个星星划过的轨迹的端点x,y(1<=x,y<=n)。
1<=n<=100000,1<=m<=min(100000,n*(n-1)/2)

Output

对于每组数据输出一个整数，表示三角形的个数。

Sample Input

1
3 3
1 2
2 3
1 3

Sample Output

1

感人的题目标题……
这题很卡常数啊……
首先对所有点进行分类。1、度数>sqrt(m)。2、度数<sqrt(m)。
剩下的事情就是分类暴力。
注意添加边的时候要手写Hash。我还开了fread挂……

 #include <bits/stdc++.h>

 using namespace std;

 const int N = ;

 #define REP(i, n)    for(int i(0); i < (n);  ++i)
 #define rep(i, a, b)    for(int i(a); i <= (b); ++i)

 int T, n, m, q, du[N];
 int x, y, ans;

 vector <int> c[N];
 vector <int> d;

 namespace IO{
        const int MT =  *  * ;
        char IO_BUF[MT];
         int IO_PTR, IO_SZ;

         void begin(){
             IO_PTR = ;
             IO_SZ = fread (IO_BUF, , MT, stdin);
         }
         template<typename T>
         inline bool scan_d (T & t){
             while (IO_PTR < IO_SZ && IO_BUF[IO_PTR] != '-' && (IO_BUF[IO_PTR] < '' || IO_BUF[IO_PTR] > ''))IO_PTR ++;
              if (IO_PTR >= IO_SZ) return false;
             bool sgn = false;
              if (IO_BUF[IO_PTR] == '-') sgn = true, IO_PTR ++;
             for (t = ; IO_PTR < IO_SZ && '' <= IO_BUF[IO_PTR] && IO_BUF[IO_PTR] <= ''; IO_PTR ++)
                 t = t *  + IO_BUF[IO_PTR] - '';
             if (sgn) t = -t;
             return true;

         }
         inline bool scan_s (char s[]){
                while (IO_PTR < IO_SZ && (IO_BUF[IO_PTR] == ' ' || IO_BUF[IO_PTR] == '\n') ) IO_PTR ++;
             if (IO_PTR >= IO_SZ) return false;
             int len = ;
             while (IO_PTR < IO_SZ && IO_BUF[IO_PTR] != ' ' && IO_BUF[IO_PTR] != '\n')
                 s[len++] = IO_BUF[IO_PTR], IO_PTR ++;
             s[len] = '\0';
             return true;
         }
 };

 namespace Hashmap{
     const int P = , seed = ;
     int u[N << ], v[N << ], nt[N << ];
     int head[P], inum;
     inline void init(){
         inum = ;
         memset(u, , sizeof u);
         memset(v, , sizeof v);
         memset(nt, , sizeof nt);
         memset(head, , sizeof head);
     }

     inline void add(int _u, int _v){
         int t = (_u * seed + _v) % P;
         u[++inum] = _u, v[inum] = _v, nt[inum] = head[t], head[t] = inum;
     }

     inline bool query(int _u, int _v){
         int t = (_u * seed + _v) % P;
         for (int p = head[t]; p; p = nt[p])
             if (u[p] == _u && v[p] == _v) return ;
         return ;
     }
 }

 int main(){

     IO::begin();
     IO::scan_d(T);

     while (T--){
         IO::scan_d(n);
         IO::scan_d(m);
         Hashmap::init();
         rep(i, , n) c[i].clear();
         memset(du, , sizeof du);
         ans = ;
         rep(i, , m){
             IO::scan_d(x);
             IO::scan_d(y);
             Hashmap::add(x, y);
             Hashmap::add(y, x);
             c[x].push_back(y);
             c[y].push_back(x);
             ++du[x], ++du[y];
         }

         d.clear();

         q = (int)sqrt((double)m);

         rep(i, , n) if (du[i] <= q){
             REP(j, (int)c[i].size())
                 if (!(du[c[i][j]] <= q && c[i][j] < i))
                     rep(k, j + , (int)c[i].size() - )
                         if (!(du[c[i][k]] <= q && c[i][k] < i))
                             if (Hashmap::query(c[i][j], c[i][k])) ++ans;
         }
         else d.push_back(i);

         REP(i, (int)d.size())
             rep(j, i + , (int)d.size() - ){
                 if (Hashmap::query(d[i], d[j]))
                     rep(k, j + , (int)d.size() - ){
                         if (Hashmap::query(d[j], d[k]))
                         if (Hashmap::query(d[i], d[k])) ++ans;
                     }
             }

         printf("%d\n", ans);
     }

     return ;

 }