Question sélection question A
Description du titre
Étant donné [Erreur de traitement mathématique] des nombres positifs, ZJM peut sélectionner exactement [Erreur de traitement mathématique] parmi ceux qui correspondent à [Erreur de traitement mathématique]. Maintenant, ZJM se demande combien de façons de l'obtenir!
entrée:
la première ligne, un entier [Erreur de traitement mathématique], indique le nombre de cas de test. Pour chaque cas, il y a deux lignes. La première ligne, trois entiers indiquent [Erreur de traitement mathématique], [Erreur de traitement mathématique] et [Erreur de traitement mathématique]. La deuxième ligne, [Math Processing Error], les nombres entiers indiquent les nombres positifs.
sortie:
Pour chaque cas, un entier indique la réponse sur une ligne indépendante.
Des idées
Ici, tous les nombres sont stockés dans un tableau. Ce tableau effectue l'opération récursive dfs. Lorsque la récursivité est k fois, elle est jugée correcte. Avant k fois, elle est supérieure à S et la récursivité doit être terminée à l'avance pour gagner du temps.
Code
#include<iostream>
using namespace std;
int n,K,S,ans;
int a[100];
void dfs(int k,int sum,int end)
{
if(sum>S)return;//提前退出
if(k==K)
{
if(sum==S) ans++;
}
else
{
for(int i=end;i<n;i++)
dfs(k+1,sum+a[i],i+1);
}
}
int main()
{
int T;
cin>>T;
while(T--)
{
cin>>n>>K>>S;
for(int i=0;i<n;i++)
cin>>a[i];
ans=0;
dfs(0,0,0);
cout<<ans<<endl;
}
return 0;
}
Résumé
Je suis coupable de cette mission à cause du jeu et de ne pas prêter attention aux avis du groupe Je n'ai rien trouvé de mal jusqu'à la fin de cette mission, o (╥﹏╥) o.
Choisir un point dans la question B
Description du titre
Il y a n intervalles fermés [a_i, b_i] sur la droite numérique. Prenez le moins de points possible pour qu'il y ait au moins un point dans chaque intervalle (les points contenus dans différents intervalles peuvent être identiques)
Entrée:
1 entier N dans la première ligne (N <= 100)
lignes 2 ~ N + 1 , Deux entiers a, b (a, b <= 100)
sortie par ligne :
un entier représentant le nombre de points sélectionnés
Des idées
La signification de cette question est très claire. Ici, j'utilise ce critère gourmand, je prends le plus petit nœud droit dans l'intervalle restant et je compare son nœud gauche avec le point de référence qui est le nœud droit de l'intervalle précédemment sélectionné. Comment peut-il être plus petit que le nœud droit? Un point peut être partagé, sinon le point de référence est mis à jour vers le nœud droit du nouvel intervalle. Ici, tous les intervalles sont triés de façon non décroissante avec le nœud droit, et les éléments en sont séquentiellement prélevés.
Code
#include<iostream>
#include<algorithm>
using namespace std;
struct mm
{
int l,r;
mm(){};
mm(int a,int b):l(a),r(b){};
bool operator<(const mm&p)
{
return r<p.r;
}
};
mm shu[101];
int n;
int main()
{
cin>>n;
for(int i=0;i<n;i++)
{
cin>>shu[i].l>>shu[i].r;
}
sort(shu,shu+n);
int count=0,nowp=-1;
for(int i=0;i<n;i++)
if(shu[i].l>nowp)
{
nowp=shu[i].r;
count++;
}
cout<<count<<endl;
return 0;
}
Résumé
Grâce à cette question, Konjac peut comprendre l'astuce de surcharger le signe inférieur à et le signe inférieur à dans la fonction cmp. Comme le montre la fonction cmp suivante, a et b peuvent être considérés comme les deux premiers éléments du tableau, a <b Il s'agit de la relation dans le tableau après tri. Dans ce cas, il s'agit d'une relation incrémentielle. Lorsque la surcharge est inférieure au signe, la structure ou la classe appelée peut être considérée comme l'ancien élément. La représentation interne de la fonction est la même que la fonction cmp. Voici également la relation incrémentielle. Compréhension du poulet
bool operator<(const mm&p)
{
return r<p.r;
}
bool cmp(const int &a,const int &b)
{
return a<b;
}
Couverture de l'intervalle de questions C
Description du titre
Il y a n (1 <= n <= 25 000) intervalles fermés [ai, bi] sur la ligne numérique. Choisissez le moins d'intervalles possible pour couvrir un segment de ligne spécifié [1, t] (1 <= t <= 1 000 000).
Couvrir tout le point, c'est-à-dire que (1,2) + (3,4) peut couvrir (1,4).
entrée: La
première ligne: N et T indiquent le numéro d'intervalle donné et la valeur de fin droite de l'intervalle à couvrir La
deuxième ligne de la ligne N + 1: chaque ligne est un intervalle fermé.
sortie:
le nombre d'intervalles sélectionnés, il est impossible de sortir -1
Des idées
Cette fois, nous utilisons le point d'extrémité gauche dans l'ordre non décroissant pour organiser. Pour chaque valeur d'extrémité gauche de l'enregistrement, nous devons trouver un élément du tableau dont le point d'extrémité gauche est inférieur ou égal à la valeur d'extrémité gauche de l'enregistrement en cours, et la valeur d'extrémité droite est aussi grande que possible. Mettez à jour pour couvrir l'intégralité de l'intervalle avec le moins d'intervalles possible.
Code
#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
struct mm
{
int l,r;
bool operator<(const mm&p)
{
return l<p.l;
}
};
mm shu[25002];
int n,T,S=1;
int main()
{
scanf("%d%d",&n,&T);
for(int i=0;i<n;i++)
{
scanf("%d%d",&shu[i].l,&shu[i].r);
}
sort(shu,shu+n);
int n_x=1,n_y=0,count=0;
int i=0;
while(n_x<=T&&i<n)
{
if(shu[i].l>n_x) break;
bool flag = 0;
for(;i<n&&shu[i].l<=n_x;i++)
{
if(shu[i].r>n_y)
{
n_y=shu[i].r;//更新最右值
flag=1;
}
}
if(flag)
{
count++;
n_x=n_y+1;
}
}
if(n_x>T) printf("%d\n",count);
else printf("-1\n");
return 0;
}
Résumé
Au début, le besoin d'indicateur n'était pas pris en compte. Le décompte ++ a été effectué pour chaque mise à jour de la valeur du point final droit, ce qui a donné un excellent résultat. Un indicateur a été défini pour indiquer que la bonne valeur a été mise à jour, ce qui a résolu le problème de l'ajout une fois de plus.
