Suiza] [ronda NOIP

Suiza] [ronda NOIP

título

tema de fondo

En el doble duelo de juegos competitivos, tales como tenis de mesa, bádminton, ajedrez, el sistema de juego es el nocaut más común y round robin. El primero se caracteriza por un pequeño número del campo de juego, cada juego emocionante, pero una mayor probabilidad. Este último se caracteriza por un número relativamente justo, baja posibilidad, pero la carrera es a menudo muy largo.

Este problema se describe en el sistema de juego redondo suizo, debido a la utilización del primer torneo de ajedrez celebrado en Suiza en 18.951.895 llamado. Puede ser visto como un compromiso con el round robin nocaut, tanto para asegurar la estabilidad del juego, sino también hacer que la carrera no será demasiado largo.

título Descripción

2 × n Número 1 ~ 2N jugadores había un total de ronda R. Antes del comienzo de cada ronda, y el final de todos los juegos, los jugadores serán a cumplir un rango descendente. La puntuación inicial jugador total es la puntuación antes del inicio de la primera ronda además ha participado en todas las competiciones y de puntuación. La misma puntuación, el número acordado de los actores más pequeños de clasificación.

Contra organizar cada ronda con la parte superior de la ronda comenzó sobre: ​​1º y 2º, 3º y 4º, ......, la primera 2K-1 y No. Nombre 2K, ......, la primera 2N-1 nombre y 2N nombre, cada uno para un juego. Cada ganador del juego recibe 1 punto, el perdedor 00 puntos. Es decir, además de la primera ronda, otra ronda de arreglo no se puede determinar de antemano, pero dependerá del rendimiento de los jugadores antes del partido.

Ahora, dado el valor inicial de la partitura y la fuerza de cada jugador, el cálculo R tras ronda, un jugador clasificado número de QQ N es la cantidad. Suponemos que el valor de la fuerza disjuntos dos a dos de los jugadores, y una elevada resistencia en cada partido siempre gana.

Formato de entrada

Las tres primeras líneas son enteros positivos N, R, Q, cada uno separado por un espacio entre los dos números, hay 2 × N representa jugadores, rondas R, nos preocupa y Q. clasificación

La segunda línea es el 2 x números enteros N no negativos S_1, s_2, ..., s_ {2N}, entre cada dos números separados por un espacio, en el que S_I si representa el número i del jugador puntuación inicial. La tercera línea es el 2 × N enteros positivos w_1, w_2, ..., w_ {2N}, entre cada dos números separados por un espacio, en el que ese número es el valor de capacidad w_i del jugador i.

Formato de salida

Un entero que es el final de la ronda R, Q clasificado como el número del jugador.

entrada y salida de la muestra

Copiar Input # 1
2 2. 4
. 7. 6. 7. 6
10. 5 20 es de 15
salidas de una copia #
1

Aquí Insertar imagen Descripción

análisis

Este es un problema desde el principio, ese tipo de una vez, una vez más, de reordenación más de una vez. . . . . . Hasta el final.
Ciertamente sentir que fosa simple. . . . . Efectivamente, a medio camino a través de la GG, varios tiempos de espera.

Ha estado utilizando sort tipo es realmente rápida clasificar y ordenar rápida. Entonces estabilizado en torno a O (nlogn)
si cada parte de los datos que han sido ordenados, un drenaje rápido o como una poligonal. . Esta es una pérdida de tiempo. .

(Véase la solución del problema del gángster). . . . . . .
Resulta que se puede hacer con la fusión. complejidad Tiempo de O (n). Más rápido y más estable.

Combinar especie: el valor de cada comparar dos matrices, que es más pequeña (grande) en la nueva matriz, (aquí algunos de combinación en línea gráfica consiguió)
Aquí Insertar imagen Descripción
Aquí Insertar imagen Descripción

Necesidad de fusionarse con la condición de que dos conjuntos tienen que ser pedidos, con el lado de valor almacenado de comparación lado.

Pero pensar en el tema. . En primer lugar, se solucionó antes del partido, de acuerdo con las puntuaciones de mayor a menor. Luego de la primera ronda.
Se coloca una victoria en la matriz, matriz de salida B.
Grupo A: antes de la orden descendente de la puntuación total se basa; 1 min después de ganar todavía había descendente;
Grupo B: antes de, en orden de puntuación total descendente se basa; sin puntos, todavía descendente.

Después de tanto que se ordena, esta vez para llevar a cabo una fusión.
Luego fusionar matriz y una buena circulación por encima de ella. . .

Se ha ordenado, el problema está resuelto.

código

//本来一直快排的代码
#include<iostream>
using namespace std;
#include<algorithm>

int n,r,q;
struct data{
	int s;		//初始分 
	int w;		//实力 
	int num;	//编号 
}d[200005];

bool cmp(data x,data y){		//按分数排序 
	if(x.s != y.s )
		return x.s > y.s;
	else
		return x.num < y.num;
}

int main(){
	cin>>n>>r>>q;
	n = n*2;
	for(int i=1;i<=n; i++){
		cin>>d[i].s;
		d[i].num = i;
	}
	for(int i=1;i<=n; i++){
		cin>>d[i].w;
		
	}
	sort(d+1,d+n+1,cmp);	
	while(r--){
		for(int i=1;i<=n;i= i+2){
			if(d[i].w > d[i+1].w){
				d[i].s += 1;
			}else if(d[i].w < d[i+1].w){
				d[i+1].s +=1;
			}
		}
		sort(d+1,d+n+1,cmp);
	}
		cout<<d[q].num<<endl;	
	return 0;
} 
//用归并的
#include<iostream>
#include<algorithm>
using namespace std;

const int maxn = 200005;
struct data{
	int grade;
	int num;
	//int w;
};
data a[maxn];
data A[100001];
data B[100001];
int w[maxn];
bool cmp(data a,data b){
	if(a.grade != b.grade){
		return a.grade > b.grade;
	}else{
		return a.num < b.num;
	}
	
}

int n,r,q;
void mergesort(){
	int i=1,j=1,k=1;
	while(i<=n && j<=n){
		if(A[i].grade > B[j].grade || 
		(A[i].grade == B[j].grade && A[i].num < B[j].num)){
			a[k].grade = A[i].grade;
			a[k].num = A[i].num;
			i++;
		}else{
			a[k].grade = B[j].grade;
			a[k].num = B[j].num;
			j++;
		}
		k++;
	}
	while(i<=n){
			a[k].grade = A[i].grade;
			a[k].num = A[i].num;
			i++;
			k++;
	}
	while(j<=n){
			a[k].grade = B[j].grade;
			a[k].num = B[j].num;
			j++;
			k++;
	}
}
int main(){
	cin>>n>>r>>q;
	for(int i=1;i<=2*n;i++){
		cin>>a[i].grade;
		a[i].num = i;
	}
	for(int i=1;i<=2*n;i++){
		cin>>w[i];
	}
	sort(a+1,a+1+2*n,cmp);

	while(r--){

	
		int tt =1;
		for(int i=1;i<2*n;i+=2){

			if(w[a[i].num] > w[a[i+1].num]){
				A[tt].grade = a[i].grade+1;
				A[tt].num = a[i].num;
				B[tt].grade = a[i+1].grade;
				B[tt].num = a[i+1].num;
			}else{
                A[tt].grade = a[i+1].grade+1;
                A[tt].num = a[i+1].num;
                B[tt].grade  =  a[i].grade;
                B[tt].num = a[i].num;
			}
			
			tt++;
		}
		mergesort();
	}
	
	cout<<a[q].num<<endl;
	return 0;
}
Publicado 75 artículos originales · ganado elogios 1 · vistas 3666

Supongo que te gusta

Origin blog.csdn.net/A793488316/article/details/104508806
Recomendado
Clasificación