El 12 ° Concurso de Diseño de Programas de Pregrado de la Universidad de Medicina Tradicional China de Zhejiang

Problema A. Programa de lenguaje C de Jhadgre

La atención es helle

Problema B. La batalla AH de Wpremig

El juego Bash se discute en tres situaciones.
Cuando m <= n, puede ganar desde el principio.
Cuando m> n y m% (n + 1) == 0, el primer movimiento debe ser derrotado.
Cuando m> n y m% (n + 1)! = 0, solo necesita tomar m% (n + 1) primero.

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;

int m, n;

int main()	
{
	while (scanf("%d%d", &n, &m) != EOF)
	{
		if (m % (n + 1) == 0)
			puts("You are loser");
		else if (n >= m)
		{
			for (int i = m; i < n; i ++)
				printf("%d ", i);
			printf("%d\n", n);
		}
		else
			printf("%d\n", m % (n + 1));
	}
	return 0;
}

Problema C. Triángulo de Wpremig

Dividir el triángulo en rectángulos con ancho d y ordenarlos de mayor a menor, luego debemos elegir los primeros rectángulos L / d para que sean óptimos en el área, luego luego de dividir infinitamente el rectángulo, supongamos que la altura del último rectángulo que elegimos es H Luego, para un triángulo con una altura mayor que H, debe haber un rectángulo con una altura H perteneciente al triángulo que se ha seleccionado. Luego, para todos los triángulos con altura mayor que H, la parte con altura H debe colocarse en el área, es decir, la altura de la intersección es H.
Conclusión:
1. El lado más corto se coloca en el eje x;
2. Cuando se determina el lado ubicado en el eje x, la solución óptima satisface la intersección de todos los triángulos en una línea recta paralela al eje x

Con las conclusiones anteriores, es obvio que cuanto más alto sea el triángulo, más fácil es elegir, por lo que cuanto más alto sea el triángulo, mejor.
Con esta conclusión, la altura del punto de bisección puede resolver fácilmente este problema.

#include <cstdio>
#include <cmath>
using namespace std;
const double eps = 1e-8;
const int maxn = 100010;

int T, cas = 1, n;
double r, a[maxn], b[maxn], c[maxn];
double area[maxn], height[maxn];

double f(double h)
{
    double ret = 0;
    for (int i=1;i<=n;i++)
        if (h < height[i]) ret += a[i] * (1.0 - h / height[i]);
    return ret;
}

int main()
{
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d%lf", &n, &r);
        for (int i=1;i<=n;i++) scanf("%lf%lf%lf", &a[i], &b[i], &c[i]);
        for (int i=1;i<=n;i++)
        {
            double p = (a[i] + b[i] + c[i]) / 2;
            area[i] = sqrt(p * (p-a[i]) * (p-b[i]) * (p-c[i]));
            height[i] = area[i] * 2 / a[i];
        }
        double low = 0, high = 1000000, mid;
        while ( fabs(high - low) > eps )
        {
            mid = (low + high) / 2;
            if (f(mid) <= r) high = mid;
            else low = mid;
        }
        double ans = 0, h = mid;
        for (int i=1;i<=n;i++)
            if (h < height[i]) ans += a[i] * (1.0 - h / height[i]) * (height[i] - h) / 2;
        printf("%.3lf\n", ans + h * r);
    }
    return 0;
}

Problema D. La escalera de Jhadgre

Enviado, tenga en cuenta que el rango de datos es más grande que int, no INT_MAX

#include <bits/stdc++.h>
using namespace std;

int main()
{
	long long n,l;
	cin>>n>>l;
	long long ans = l;
	for (int i = 0 ; i < n ; ++i) {
		long long x;cin>>x;
		if (x > ans) ans = x;
	}
	cout<<ans - l<<endl;
	return 0;
} 

Problema E. Formación del coro de Jhadgre

Originalmente quería hacer que el árbol del conjunto de árboles pudiera pasar ... Sin embargo, el límite de tiempo y la limitación de espacio del título son más incómodos, así que simplemente lo cambié a la dicotomía general.

Primero considere si solo pregunta una vez, luego suponga que el orden de la pregunta es k, podemos dividir la respuesta por la mitad, cada verificación es para atravesar todas las modificaciones, construir una matriz de árbol, para una operación de sumar un número z al intervalo [x, y], Si z> = mid, entonces dé +1 al intervalo completo de [a, b]. Finalmente, la suma del intervalo de consulta, es decir, el número de números> = medio en este intervalo. Si este número> = k, divida por dos y registre la respuesta; de lo contrario, divida por dos

Podemos encontrar que el lugar que más tiempo consume es el mantenimiento, y la operación de mantenimiento solo está relacionada con la mitad y no tiene nada que ver con consultas específicas. Por lo tanto, considere procesar las consultas y coloque todas las consultas que deben ser de "dicotomía ascendente" (es decir, [mid + 1, r]) y consultas de "dicotomía descendente" (es decir, [l, mid]) en un conjunto cada vez, Por supuesto, al mismo tiempo, los cambios que puedan afectarlos también deben agregarse a la colección después de la consulta, y luego la operación continuará de forma recursiva por separado.

Para una consulta, si la suma del intervalo de consulta es mayor o igual que la clasificación de la consulta, la consulta se divide en el conjunto de "dicotomía ascendente", de lo contrario, se divide en el conjunto de "dicotomía descendente".

Para la modificación, si el número agregado por una modificación es <= mid, entonces no debe contribuir a la consulta que se ha determinado que se responde en [mid + 1, r], por lo que solo debe agregarse al conjunto de "dicotomía descendente"; de lo
contrario Entonces esta modificación debe haber contribuido a la consulta del intervalo [l, mid]. Si resta 1 de la clasificación de la pregunta en [l, mid], esta modificación solo contribuirá a las consultas en el conjunto "dicotomía ascendente", así que agregue esta modificación a la dicotomía "ascendente" En la colección.

En cuanto al número de ellos, solo use BIT para mantenerlo, actualización de intervalo + consulta de intervalo.

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define MAXN 50005
typedef long long LL;
using namespace std;
int n,m,id[MAXN],t1[MAXN],t2[MAXN],T=0;
LL ans[MAXN];

LL read(){
    LL x=0,f=1;char c=getchar();
    while(c<'0'||c>'9'){
        if(c=='-')f=-1;c=getchar();
    }
    while(c>='0'&&c<='9'){
        x=x*10+c-'0';c=getchar();
    }
    return x*f;
}

struct Node1{
    int opt,a,b;
    LL c;
}O[MAXN];
struct BIT{
    LL c[MAXN];int sign[MAXN];
    int lowbit(int x){return x&-x;}
    void add(int pos,int x){
        while(pos<=n){
            if(sign[pos]!=T)c[pos]=0,sign[pos]=T;
            c[pos]+=x,pos+=lowbit(pos);
        }
    }
    LL query(int pos){
        LL res=0;
        while(pos>0){
            if(sign[pos]!=T)c[pos]=0,sign[pos]=T;
            res+=c[pos],pos-=lowbit(pos);
        }
        return res;
    }
}c1,c2;

void ADD(int a,int b){
    c1.add(a,1),c1.add(b+1,-1);
    c2.add(a,a),c2.add(b+1,-b-1);
}
LL QUERY(int a,int b){
    LL res=0;
    res+=(b+1)*c1.query(b)-c2.query(b);
    res-=a*c1.query(a-1)-c2.query(a-1);
    return res;
}
void solve(int l,int r,int ansl,int ansr){
    if(l>r)return;
    if(ansl==ansr){
        for(int i=l;i<=r;i++)
        if(O[id[i]].opt==2)ans[id[i]]=ansl;
        return;
    }
    int mid=(ansl+ansr)>>1;
    int j=1,k=1;
    T++;
    for(int i=l;i<=r;i++){
        int idx=id[i];
        if(O[idx].opt==1){
            if(O[idx].c<=mid)t1[j++]=idx;
            else t2[k++]=idx,ADD(O[idx].a,O[idx].b);
        }
        else{
            LL res=QUERY(O[idx].a,O[idx].b);
            if(res>=O[idx].c)t2[k++]=idx;
            else t1[j++]=idx,O[idx].c-=res;
        }
    }
    --j,--k;
    for(int i=1;i<=j;i++)id[l+i-1]=t1[i];
    for(int i=1;i<=k;i++)id[l+j+i-1]=t2[i];
    solve(l,l+j-1,ansl,mid),solve(l+j,r,mid+1,ansr);
}

int main()
{
    n=read(),m=read();
    for(int i=1;i<=m;i++){
    	O[i].opt=read();
		O[i].a=read();
		O[i].b=read();
		O[i].c=read();
		id[i]=i;
	}
    solve(1,m,-n,n);
    for(int i=1;i<=m;i++)
    	if(O[i].opt==2)
			printf("%d\n",ans[i]);
    return 0;
}

Problema F.Jhadgre está triste

Recursión, pequeña dp, solo escribe casualmente.

#include <bits/stdc++.h>
using namespace std;
int n;
int a[100000];
int fun(int x){
	if (x > n) return 0;
	return min(fun(a[x]),fun(x + 5)) + 1;
}

int main()
{
	scanf("%d",&n);
	for (int i = 1 ; i <= n ; ++i)
		scanf("%d",&a[i]);
	cout<< fun(1) * 2<<endl; 
	return 0;
} 

Problema G. Problema de pesaje de Wpremig

Primero, dé una conclusión: si necesita encontrar bolas de diferente calidad y conocer el peso de y veces, el número máximo de bolas que se pueden pesar es n = $(3^k-3)/2$

La idea de prueba es la siguiente, y el lema se prueba a su vez:
Lema 1:
Si hay m bolas o estándar o más pesadas que el estándar, y n bolas son estándar o más livianas que el estándar y al menos una bola estándar, entonces se pueden pesar k veces La condición necesaria y suficiente para determinar qué bola es: $metro+norte\le 3^k$

Lema 2:
Si hay n bolas que no saben si son de peso estándar, más livianas o más pesadas, y al menos una bola estándar, la condición necesaria y suficiente para k tiempos para determinar qué bola es: $norte\le 1/2(3^k+1)$

Lema 3:
Si hay n bolas sin saber si es un peso estándar, más liviano o más pesado, y al menos una bola estándar, entonces k veces de peso pueden determinar qué bola es y si la bola es más liviana o más pesada. La condición esencial es: $norte\le 1/2(3^k-1)\; La$
idea para demostrar la suficiencia del Lema 1 es:
Sea$metro=3yo+j,norte=3k+r$ . Ponga i en cada lado que puede ser pesado yk que puede ser ligero, y luego j, r = 0, 1, 2 para un total de 9. Discuta la clasificación y discútala de forma recursiva.
La necesidad es obvia.
La idea de prueba de la suficiencia del Lema 2 es:
$(3^k+1)/2$ bolas, la primera vez$(3^{k-1}+1)/2$ bolas a la izquierda,$(3^{k-1}-1)/2$ bolas más la bola estándar de la derecha, las restantes$(3^{k-1}+1)/2\; Después$ del primer pesaje, el equilibrio puede probarse por recursividad o el desequilibrio puede probarse por lema.
La prueba de suficiencia del Lema 3 tiene la misma idea, la diferencia radica en el resto$(3^{k-1}-1)/2$ bolas.
La idea de la prueba de la necesidad del Lema 3 es la misma que la de la pregunta 2.
La prueba comparativa del Lema 2 es más problemática, pero la idea sigue siendo similar. Si el primer pesaje no está equilibrado, utilice el Lema 1 y, si está equilibrado, recursivamente.
Al final, la demostración de los dos problemas debe discutirse por separado para el primer pesaje, porque no hay una bola estándar para pedir prestada, y el número es uno menos que en el lema, y ​​luego puede usar la conclusión del lema para probar con ideas similares.

#include <bits/stdc++.h>
using namespace std;
int main(){
	int x,y;
	while (~scanf("%d%d",&x,&y)){
		if (x <= 2){
			puts("No");
			continue;
		}
		long long now = 3;
		int k;
		for (k = 2 ; k < 15 ; ++k){
			now *= 3;
			if ((now-3)/2 >= x) break;
		}
		if (k <= y) puts("Yes");
		else puts("No");
	}
	return 0;
} 

Problema H. ​​El camino a casa de Jhadgre

Obviamente, es difícil buscar según el camino de "L" → "W" → "Q" porque es necesario ir primero a cada "W" y luego buscar el camino más corto a "Q" desde "W", pero este camino se puede imaginar. Se convierte en "L" → "W" ← "Q", por lo que no es necesario considerar "W".
Entonces, dos veces de bfs, comenzando desde "L" y comenzando desde "Q", y luego atravesando cada "W", la suma de las rutas más cortas desde "L" y "Q" hasta este punto es la clave El camino más corto de regreso al dormitorio, solo pide el más corto.

O dos veces de bfs, comenzando desde "L" y "Q" respectivamente, haz dos bfs y luego recorre todo el mapa para juzgar el camino más corto para todas las "W"

#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;

const int MAXN = 2010;
const int INF = 0x3f3f3f3f;

int n, m;
int vis[MAXN][MAXN];
int ret[2][MAXN][MAXN];
char a[MAXN][MAXN];
int xx[4] = {1,-1,0,0};
int yy[4] = {0,0,1,-1};

void bfs(int xxx, int yyy, int d) {
	queue< pair<int, int> > q;
	q.push(make_pair(xxx, yyy));
	vis[xxx][yyy] = 1;
	ret[d][xxx][yyy] = 0;
	while(!q.empty()) {
		int tx = q.front().first;
		int ty = q.front().second;
		q.pop();
		for (int i = 0;i < 4; ++i) {
			int x = tx + xx[i];
			int y = ty + yy[i];
			if (x >= 0 && x < n && y >= 0 && y < m && a[x][y] != '#' && !vis[x][y]) {
				ret[d][x][y] = ret[d][tx][ty] + 1;
				vis[x][y] = 1;
				q.push(make_pair(x, y));
			}
		}
	}
}

int main() {
	while (~scanf("%d %d", &n, &m)){
		queue< pair<int, int> > q;
		memset(ret, INF, sizeof(ret));
		memset(vis, 0, sizeof(vis));
		int sx, sy;
		int tx, ty;
		for (int i = 0;i < n; ++i) {
			scanf("%s", a[i]);
			for (int j = 0;j < m; ++j) {
				if (a[i][j] == 'W') {
					q.push(make_pair(i, j));
				} else if (a[i][j] == 'L') {
					sx = i;
					sy = j;
				} else if (a[i][j] == 'Q') {
					tx = i;
					ty = j;
				}
			}
		}
		bfs(sx, sy, 0);
		memset(vis, 0, sizeof(vis));
		bfs(tx, ty, 1);
		int ans = INF;
		while(!q.empty()) {
			int x = q.front().first;
			int y = q.front().second;
			q.pop();
			ans = min(ans, ret[0][x][y] + ret[1][x][y]);
		}
		printf("%d\n", ans);
	}
	return 0;
}

Problema I. Galletas de Jhadgre

Envíe el título, string.find ()

#include <bits/stdc++.h>
using namespace std;

int main()
{
	int N;scanf("%d",&N);
	int ans = 0 ;
	while (N--){
		string x;cin>>x;
		if (x.find("zailaiyihe") != string::npos){
			ans++;
		} 
	} 
	cout<<ans<<endl;
	return 0;
} 

Problema J. Jhadgre subiendo escaleras

Doble para bucle es suficiente ... tenga en cuenta que el módulo no es $1y9+7$ es$1y8+7$

#include <iostream>
#include <cstdio>
using namespace std;
const int mod = 100000007;
int dp[10100];
int main() {
	int n;
    dp[0] = 1;
    for (int i = 1; i <= 10000; ++i) {
        dp[i] = dp[i - 1];
        for (int j = i - 2; j >= 0; j -= 2) {
            dp[i] += dp[j];
            dp[i] %= mod;
        }
    }
    while (cin>>n)
    	cout << dp[n] << endl;
    return 0;
}

Problema K. Jhadgre 的 π

Son posibles la fórmula BBP o varios métodos de convergencia.
http://www.huanqiujiemi.com/7xqE25x.html
imagen de referencia ... un libro publicado en Japón

#include <cstdio>
#include <cmath>
#include <iostream>
#define MAX_C 56000
int a = 10000, b, c = MAX_C, d, e, f[MAX_C + 1], g, n, ans, cnt;
using namespace std;

int main()
{
	int pp;
    scanf("%d", &n);
    a = 10000;
	b = d = e = g = ans = cnt = 0;
	c = MAX_C; 
	for (; b - c; ) f[b++] = a / 5;
    for (; d = 0, g = c * 2; c -= 14, ans = e + d / a, e = d % a, cnt++) {
        if (cnt * 4 > n) break;
        for (b = c; d += f[b]*a, f[b] = d % --g, d /= g--, --b; d *= b);
    }
    if (n % 4 == 0) cout << (ans / 1000);
    else if (n % 4 == 1) cout << ((ans / 100) % 10);
    else if (n % 4 == 2) cout << ((ans / 10) % 10);
    else if (n % 4 == 3) cout << (ans % 10);
    cout<<endl;
	return 0;
}

El problema del Niuniu de L. Wpremig

Preguntas de lectura en inglés
Primero use una matriz de cinco dimensiones para preprocesar todas las puntuaciones posibles, y luego sume directamente cada conjunto de datos y luego / 13. Preste atención al redondeo.

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>

inline void read(int &x)
{
    x = 0;char ch = getchar(), c = ch;
    while(ch < '0' || ch > '9')c = ch, ch = getchar();
    while(ch <= '9' && ch >= '0')x = x * 10 + ch - '0', ch = getchar();
    if(c == '-')x = -x;
}

inline int min(int a,int b)
{return a<b?a:b;}

int ans[15][15][15][15][15];
int x,y,m,n,z,sum;

inline void init()
{
    for(int a = 1;a <= 13;++ a)
        for(int b = 1;b <= 13;++ b)
            for(int c = 1;c <= 13;++ c)
                for(int d = 1;d <= 13;++ d)
                    for(int e = 1;e <= 13;++ e)
    {
        if(a<5 && b<5 && c<5 && d<5 && e<5 && a+b+c+d+e <= 10)
            ans[a][b][c][d][e] = 60;
        else if(a>10 && b>10 && c>10 && d>10 && e>10)
            ans[a][b][c][d][e] = 50;
        else if((a==b && b==c && c==d) || (a==b && b==c && c==e) || (a==b && b==d && e==d) || (a==e && e==c && c==d) || (e==b && b==c && c==d))            
            ans[a][b][c][d][e] = 40;
        else
        {
            x = min(a,10),y = min(b,10),m = min(c,10),n = min(d,10),z = min(e,10);
            if((x+y+m)%10 == 0 || (y+m+n)%10 == 0 || (m+n+z)%10 == 0 || (x+y+n)%10 == 0 || (x+y+z)%10 == 0 || (y+m+z)%10 == 0 || (y+n+z)%10 == 0 || (x+n+z)%10 == 0 || (x+m+n)%10 == 0 || (x+m+z)%10 == 0)
            {
                sum = x+y+m+n+z;
                if(sum%10 == 0)
                    ans[a][b][c][d][e] = 30;
                else if(sum%10 < 7)
                    ans[a][b][c][d][e] = sum%10;
                else
                    ans[a][b][c][d][e] = (sum%10)*2;
            }
        }
    }
}

int main()
{
    init();
    int t;
    read(t);
    for(;t;--t)
    {
        sum = 0;
        read(x),read(y),read(m),read(n);
        for(register int i = 1;i <= 13;++ i)
            sum += ans[x][y][m][n][i];
        sum = (sum/13.0)+0.5;
        printf("%d\n",sum);
    }
    return 0;
}

Problema M. Mapa del tesoro de Wpremig y Jhadgre

Colorea el gráfico en blanco y negro.
Establece el número de cuadrículas negras como negro, el número de
cuadrículas blancas como blanco y
establece el valor de las cuadrículas negras y sumblack y la suma
de los valores de las cuadrículas blancas como sumwhite

Suponga que el número de cada cuadrícula al final se convierte en x, luego
negro * x - sumblack = blanco * x - sumwhite
x = (sumblack - sumwhite) / (negro - blanco)

1. Cuando negro ≠ blanco, puede resolver x y luego usar la verificación de flujo de red
2. Cuando negro = blanco, puede encontrar que para una x legal, k> = x es una solución legal
porque negro = blanco => (negro + blanco)% 2 == 0 puede construir una capa de cobertura total,
por lo que puede dividir x en dos y usar el flujo de red para verificar

Para comprobar la
construcción:
si el punto k es blanco, cree un borde (s, k, x - v [k])
si el punto k es negro, cree un borde (k, t, x - v [k])
al punto adyacente u , V (u es blanco), construya un borde (u, v, inf) para
determinar si el flujo está completo.

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define LL long long
const int s=1690,t=1691;
const LL oo2=1e17,oo1=1e13,oo3=1e15;
int a[50][50],num[50][50],xx[]={0,0,1,-1},yy[]={1,-1,0,0},
fir[1700],ne[10010],to[10010],que[1700],f[1700],
m,n,tot;
LL w[10010];
bool ok(int x,int y)
{
    return x>=1&&x<=n&&y>=1&&y<=m;
}
void init()
{
    int i,j;
    scanf("%d%d",&n,&m);
    for (i=1;i<=n;i++)
      for (j=1;j<=m;j++)
        scanf("%d",&a[i][j]);
}
void add(int u,int v,LL x)
{
    tot++;
    ne[tot*2]=fir[u];
    fir[u]=tot*2;
    to[tot*2]=v;
    w[tot*2]=x;
    ne[tot*2+1]=fir[v];
    fir[v]=tot*2+1;
    to[tot*2+1]=u;
    w[tot*2+1]=0;
}
bool find()
{
    int hd=1,tl=1,i,u,v;
    que[1]=s;
    memset(f,0,sizeof(f));
    f[s]=1;
    while (hd<=tl)
    {
        u=que[hd++];
        for (i=fir[u];i;i=ne[i])
          if (w[i]&&!f[v=to[i]])
          {
            f[v]=f[u]+1;
            que[++tl]=v;
          }
    }
    return f[t];
}
LL dfs(int u,LL lim)
{
    int i,v;
    LL ret=0,x;
    if (u==t) return lim;
    for (i=fir[u];i&&ret<lim;i=ne[i])
      if (w[i]&&f[v=to[i]]==f[u]+1)
      {
        x=dfs(v,min(lim-ret,w[i]));
        ret+=x;
        w[i]-=x;
        w[i^1]+=x;
      }
    if (!ret) f[u]=0;
    return ret;
}
bool ok(LL x)
{
    int i,j,kk,x1,y1;
    tot=0;
    memset(fir,0,sizeof(fir));
    for (i=1;i<=n;i++)
      for (j=1;j<=m;j++)
        if (i+j&1) add(s,num[i][j],x-a[i][j]);
        else add(num[i][j],t,x-a[i][j]);
    for (i=1;i<=n;i++)
      for (j=1;j<=m;j++)
        if (i+j&1)
          for (kk=0;kk<4;kk++)
            if (ok(x1=i+xx[kk],y1=j+yy[kk]))
              add(num[i][j],num[x1][y1],oo3);
    while (find())
    {
        int xxx;
        xxx=1;
        while (dfs(s,oo2));
    }
    for (i=fir[s];i;i=ne[i])
      if (w[i]) return 0;
    return 1;
}
void solve1()
{
    int i,j;
    LL s0=0,s1=0,x;
    for (i=1;i<=n;i++)
      for (j=1;j<=m;j++)
        if (i+j&1) s1+=a[i][j];
        else s0+=a[i][j];
    x=s0-s1;
    for (i=1;i<=n;i++)
      for (j=1;j<=m;j++)
        if (a[i][j]>x)
        {
            printf("-1\n");
            return;
        }
    if (!ok(x)) printf("-1\n");
    else printf("%lld\n",(x*m*n-s0-s1)/2);
}
void solve0()
{
    int i,j;
    LL s0=0,s1=0,x,l,r,mid;
    for (i=1;i<=n;i++)
      for (j=1;j<=m;j++)
        if (i+j&1) s1+=a[i][j];
        else s0+=a[i][j];
    if (s0!=s1)
    {
        printf("-1\n");
        return;
    }
    l=0;
    for (i=1;i<=n;i++)
      for (j=1;j<=m;j++)
        l=max(l,(LL)a[i][j]);
    r=oo1;
    while (l<r)
    {
        mid=(l+r)/2;
        if (ok(mid)) r=mid;
        else l=mid+1;
    }
    if (l==oo1) printf("-1\n");
    else printf("%lld\n",(l*m*n-s0-s1)/2);
}
int main()
{
    int T,i,j;
    for (i=1;i<=40;i++)
      for (j=1;j<=40;j++)
        num[i][j]=i*40+j;
    scanf("%d",&T);
    while (T--)
    {
        init();
        if (m*n&1) solve1();
        else solve0();
    }
}