répartition entre tableaux

Version imprimable

20/11/2014, 18h58
Student_Master

répartition entre tableaux
Bonsoir,

Pourriez-vous m'aider svp !

J'ai un nombre de ressources (nr = 10)
Un nombre de classes (nc = 3)
R[maxC] = tableau contenant la liste des ressources.
Je souhaiterai répartir les 10 ressources dans les trois classes d'une façon aléatoire de telle sorte que chaque classe doit contenir au mois une ressource.

Exp de résultat attendu pour les trois classes :
Code:

1 2 3 R[0] = {0, 5, 4, 9} R[1] = {1, 2, 8} R[2] = {3, 6, 7}
Mon essai :
Code:

1 2 3 4 5 6 7 8 int nbr_alea; for(c=0; c<nc; c++) // nombre de classes { nbr_alea = rand ()% nr; R[c] = nbr_alea ; nr--; cerr << " " << R[c] << endl; }
Merci.
21/11/2014, 01h00
bacelar

Tu vas avoir des doublons et tu n'auras pas de garantie d'avoir au moins une ressource par catégorie (en POO, les classes c'est pas la même chose).

Donc, plutôt que de tirer au hasard la ressource, tu les mélanges :
http://en.cppreference.com/w/cpp/alg...random_shuffle

Mais pour cela, le plus simple c'est d'utiliser des st::vector, aussi bien pour mélanger la liste des ressources que stocker les ressources par catégorie.
http://www.cplusplus.com/reference/vector/vector/

En gros, tu construis un vector avec toutes les ressources, tu le mélange avec random_shuffle.
Tu construis un vector "ListeDeCategorie" contenant autant de catégorie que nécessaire. les éléments de ce vector étant eux-mêmes des vector mais de ressources (int?).

Tu prends les "nc" premiers éléments du vector des ressources après leur mélange et tu les ajoutes à chacun des "nc" premiers éléments de "ListeDeCategorie", la ressource correspondante.

Il ne restera dans le vector des ressources que nr-nc ressources non encore assignées à une catégorie.
Il suffit de faire une boucle sur "nr-nc", et à chaque tour de boucle, tirer un nombre entre 0 et nc pour désigner à quel élément de "ListeDeCategorie" sera affectée la ressource.

Donc, on laisse tomber les tableaux C et on utilise correctement la STL C++.

Nouvelle exposition du problème

Re,

Je vous expose le problème d'une autre manière.
Supposant que j'ai la matrice de présence du personnel (10 ressources et 10 périodes) suivante :
Code:

1 2 3 4 5 6 7 8 9 10 1 0 1 0 1 1 0 1 1 1 1 0 0 1 1 1 1 0 1 0 0 1 1 0 0 0 0 0 0 1 1 0 0 0 1 1 0 1 0 1 1 1 1 1 0 0 0 0 1 1 1 1 0 0 0 1 0 1 1 0 1 1 0 0 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 1 1 0 1 0 1 1 0 1 1 1
Chaque ressource a par conséquent un vecteur sur 10 périodes. Une classe contient la liste des ressources qui ont des vecteurs identiques. Afin de créer les classes, on passe par la vérification des vecteurs de toutes les ressources.
Dans un premier cas, on stocke la ressource 0 dans la classe 0. Après, on vérifie si le vecteur de la ressource 0 est identique a celui de la ressource 1. Si c'est identique on stocke la ressource 1 dans la classe 0 sinon on la stocke dans la classe 1. Ainsi de suite jusqu'à la fin.
Le tableau qui contient la liste des classes est donné par R[maxC].
Si on applique cette logique sur cet exemple nous aurons le résultat suivant :
Code:

1 2 3 4 5 6 7 R[0] = {0,9} R[1] = {1} R[2] = {2,7} R[3] = {3} R[4] = {4} R[5] = {5} R[6] = {6,8}
Merci pour vos propositions.

21/11/2014, 16h42
bacelar

Ce problème n'a strictement rien à voir avec le précédant.

Mais la conclusion est strictement la même :

Citation:

Donc, on laisse tomber les tableaux C et on utilise correctement la STL C++. .

Vous construisez une clé avec le vecteur de chaque ressource.
10 booléens, pour faire une clé, c'est pas trop dur => un bitsfield de 10 qu'on peut facilement simplifier par un int16 et quelque left shift logique (<<).

Chaque catégorie (pas classe SVP, en POO c'est un terme bien loin de celui des maths) a donc une clé unique.

Vous utilisez une multimap (http://www.cplusplus.com/reference/map/multimap/) ou une unordered_multimap (http://www.cplusplus.com/reference/u...ered_multimap/) pour stocker les différentes ressources avec la clé associée à celle-ci.

A la fin, vous aurez les ressources regroupées par catégorie dans la multimap.

Il n'y qu'un calcul de clé et un add dans une map à faire dans une boucle sur les ressources.

C'est donc un exercice faisable en 5 lignes, déclarations comprises.
21/11/2014, 16h53
Student_Master

Je vous remercie pour votre réponse. En effet, je n'ai pas trop de connaissances pour coder à votre manière.
Par conséquent, je veux utiliser les tableaux pour deux raisons :
1) Je suis entrain de résoudre un modèle mathématique à l'aide de Cplex. En revanche, j'ai déjà codé 500 lignes de code en utilisant les tableaux et je veux que ça soit cohérents entre eux.
2) Pour suivre votre démarche, ça va me perdre beaucoup de temps pour changer le reste de mon code avec les nouvelles variables.
Si, vous permettez de m'aider à faire ce bout de code avec les tableaux.
En vous remerciant par avance.

VIREZ VOS TABLEAUX DE MERDE.

Version TABLEAUX DE MERDE

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include <windows.h>
#include <map>
#include <vector>
#include <algorithm>
...
	int tableauDeMerdeEnEntre[10][10]={
		{1,0,1,0,1,1,0,1,1,1},
		{1,0,0,1,1,1,1,0,1,0},
		{0,1,1,0,0,0,0,0,0,1},
		{1,0,0,0,1,1,0,1,0,1},	
		{1,1,1,1,0,0,0,0,1,1},	
		{1,1,0,0,0,1,0,1,1,0},	
		{1,1,0,0,0,0,0,0,1,1},
		{0,1,1,0,0,0,0,0,0,1},	
		{1,1,0,0,0,0,0,0,1,1},	
		{1,0,1,0,1,1,0,1,1,1}
	};
 
	std::multimap<int,int> mymap;
 
	for(int i = 0 ; i<10 ;i++)
	{
		int key = 0;
 
		for(int j = 0 ; j<10 ;j++)
		{
			key += tableauDeMerdeEnEntre[i][j] << j;
		}
		mymap.insert(std::pair<int,int>(key,i));
	}
 
	std::vector<std::vector<int>> myvector;
 
	int maxCardinalite = 0;
	int nbCategorie = 0;
 
	for( auto iter = mymap.begin() ; iter != mymap.end() ; iter = mymap.upper_bound(iter->first) )
	{
		std::vector<int> mylist;
		for(auto iter2 = iter ; iter2 != mymap.upper_bound(iter->first) ; ++iter2)
		{
			mylist.push_back(iter2->second);
			maxCardinalite = (maxCardinalite > mylist.size()) ? maxCardinalite : mylist.size();
		}
		myvector.push_back(mylist);
		nbCategorie++;
	}
 
	int* tableauDeMerdeEnSortie = (int*)malloc(maxCardinalite*nbCategorie*sizeof(int));
	ZeroMemory(tableauDeMerdeEnSortie,maxCardinalite*nbCategorie*sizeof(int));
 
	std::sort(begin(myvector),end(myvector),[](std::vector<int> a, std::vector<int> b){return a[0]<b[0];});
 
 
	int ligne = 0;
	for( auto& const i : myvector )
	{
		int colone = 0;
		for( auto j : i)
		{
			tableauDeMerdeEnSortie[ligne*maxCardinalite+colone] = j;
			colone++;
		}
		ligne++;
	}

Version "normale" même en voulant trié les catégories :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <map>
#include <vector>
#include <algorithm>
...
	int tableauDeMerdeEnEntre[10][10]={
		{1,0,1,0,1,1,0,1,1,1},
		{1,0,0,1,1,1,1,0,1,0},
		{0,1,1,0,0,0,0,0,0,1},
		{1,0,0,0,1,1,0,1,0,1},	
		{1,1,1,1,0,0,0,0,1,1},	
		{1,1,0,0,0,1,0,1,1,0},	
		{1,1,0,0,0,0,0,0,1,1},
		{0,1,1,0,0,0,0,0,0,1},	
		{1,1,0,0,0,0,0,0,1,1},	
		{1,0,1,0,1,1,0,1,1,1}
	};
 
	std::multimap<int,int> mymap;
 
	for(int i = 0 ; i<10 ;i++)
	{
		int key = 0;
 
		for(int j = 0 ; j<10 ;j++)
		{
			key += tableauDeMerdeEnEntre[i][j] << j;
		}
		mymap.insert(std::pair<int,int>(key,i));
	}
 
	std::vector<std::vector<int>> myvector;
 
	for( auto iter = mymap.begin() ; iter != mymap.end() ; iter = mymap.upper_bound(iter->first) )
	{
		std::vector<int> mylist;
		for(auto iter2 = iter ; iter2 != mymap.upper_bound(iter->first) ; ++iter2)
		{
			mylist.push_back(iter2->second);
		}
		myvector.push_back(mylist);
	}
 
	std::sort(begin(myvector),end(myvector),[](std::vector<int> a, std::vector<int> b){return a[0]<b[0];});

22/11/2014, 00h38
Student_Master

Merci pour votre proposition mais vous auriez pu me répondre gentiment !
Cordialement,

hello,

variante plus proche de l'esprit initial de l'algo:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
#include <map>
#include <vector>
int main(){
  int tableauDeMerdeEnEntre[10][10]={
    {1,0,1,0,1,1,0,1,1,1},
    {1,0,0,1,1,1,1,0,1,0},
    {0,1,1,0,0,0,0,0,0,1},
    {1,0,0,0,1,1,0,1,0,1},  
    {1,1,1,1,0,0,0,0,1,1},  
    {1,1,0,0,0,1,0,1,1,0},  
    {1,1,0,0,0,0,0,0,1,1},
    {0,1,1,0,0,0,0,0,0,1},  
    {1,1,0,0,0,0,0,0,1,1},  
    {1,0,1,0,1,1,0,1,1,1}
  };
 
  std::map<int, int> tokens;
  typedef std::vector<int> row;
  std::vector<row> myClasses;
  for(int i = 0 ; i<10 ;i++)
  {
    int key = 0;
 
    for(int j = 0 ; j<10 ;j++)
    {
      key += tableauDeMerdeEnEntre[i][j] << j;
    }
    if(tokens.find(key) == tokens.end()){
      myClasses.push_back(row(1,i));
      tokens[key] = myClasses.size()-1;
    }else{
      myClasses[tokens[key]].push_back(i);
    }
  }
  return 0;
}

si la classe existe pas on la crée...
les classes sont par définition triées par l'ordre d'apparition des personnes.

ps: un vector est un tableau non ;)

22/11/2014, 14h54
Student_Master

Merci à vous tous :)

Citation:

ps: un vector est un tableau non

Effectivement.
23/11/2014, 15h47
sambia39

Bonjour
La première fois que j'ai lu ce poste, je me suis dit pourquoi pas les vecteurs, c'est une bonne idée mais, utilisé les outils de vecteur sans avoir tous les donnés ou informations sur le but réel est une erreur et en plus on ne répons pas à la question posée on impose une solution sans comprendre; pire encore, en prend même pas le temps de comprendre la complexité et le modèle mathématique du problème qui ce cache derrière la question surtout, s'il s'agit de répartition des ressources ou de charge de façon non déterministe( par exemple ).
Bref, on ne va pas utiliser les vecteurs parce que c'est jouette et que ça marche. La personne en face ne maîtrise pas forcément le langage C++ et préfère passer sur un modèle classique en langage C qu'il connais et c'est un choix qui lui appartient, faut la respecter et non dire "VIREZ VOS TABLEAUX DE MERDE / Version TABLEAUX DE MERDE" et faire comme ça, se n'est pas la bonne solution;
Le mieux, est de lui demander tout simplement, que veut-il faire concrètement, pourquoi le choix d'un tableaux ?
faut-il penser graphe ou autres et quel est le modèle algorithmique qu'il quant utiliser ou du moins faire ?
peut-il nous en donner un modèle, un exemple avec le code qu'il a écrit afin de l'aidé ? etc.
Un autre langage comme le Python n'est 'il pas adapté ? (émettre des idées pour l'aider pas le contraire)
Ce n'est qu'après tout ça quand peut ce dire pour des raison optimale ou peut importe, que pour étape X du programme il est idéal ou nécessaire d'utiliser les vecteurs où des outils du langages C/C++ voir un autre langage de programmation et de plus, en maitrise ce que l'on fais tout en gardon l'idée initiale. ( bref )
Quant à la question posé, peux-tu nous soumettre ton modèle algorithme avec le code que tu as fait ? et vue ton modèle, serait-il pas mieux d'utiliser un modèle (exemple en graphe, graphe acyclique, méthode perd, liste d'adjacence), etc. ?
Cordialement.

Bonjour,

Citation:

Quant à la question posé, peux-tu nous soumettre ton modèle algorithme avec le code que tu as fait ?

Je vous envoie tout le code.
J'ai inséré le bout de code de

Citation:

galerien69

il se trouve à la ligne :

Citation:

413

J'ai essayé de l'adapter avec mes variables mais je ne suis pas arrivé à avoir écrire le résultat dans le fichier de sortie à la ligne

Citation:

523

Le résultat de ce tableau contenant la liste des ressources est stocké dans :

Citation:

R[maxC]

qui sera utilisé dans la contrainte numéro 16 ( ligne

Citation:

238)

.
La question : comment peut-on adapter ce code avec R[c], de pouvoir l'écrire par la suite dans le fichier texte et ainsi de l'utiliser dans les contraintes ?
Le code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
#define TRACE1		// trace pour affichage
#include <ilcplex/ilocplex.h>
#include <iostream>  // C++ header file for I/O
#include <fstream>
#include <sstream>
#include <cmath>
#include <ctime>
#include <vector>
#include <ctime>
#include <cmath>
#include <math.h>       /* round, floor, ceil, trunc */
#include <map>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <cstdlib> 
 
#ifdef WIN64
	#include <windows.h>
#endif
 
using namespace std;
 
ILOSTLBEGIN
 
typedef IloArray<IloIntArray2>       IloIntArray3;
typedef IloArray<IloIntVarArray>     IloIntVarArray2;
typedef IloArray<IloNumVarArray>     IloNumVarArray2;
typedef IloArray<IloNumVarArray2>    IloNumVarArray3;
typedef IloArray<IloIntVarArray2>    IloIntVarArray3;
typedef IloArray<IloBoolArray>       IloBoolArray2;
typedef IloArray<IloBoolVarArray>    IloBoolVarArray2;
typedef IloArray<IloBoolVarArray2>   IloBoolVarArray3;
typedef IloArray<IloBoolVarArray3>   IloBoolVarArray4;
 
//  Temps de calcul long
time_t start1;	/**< debut mesure temps de calcul */
time_t end1;	/**< fin mesure temps de calcul */
 
// ************** parameters *********** //
 
const int maxR=3000;	/**< max of ressource */
const int maxC=3000;	/**< max of classes */
const int maxT=20;		/**< max of periods */
 
int		 nr;			/**< number of resource = R */
int		 dm;	     	/**< number of periods  = T */
int		 nclasses;		/**< number of classes  = C */
 
// ****** List of tables ******** //
 
int		 Q[maxR][maxT];			 /** Matrice de presence du personnel */
int		 H[maxT];				 /** Nombre de postes difficiles a la periode t */
int		 P[maxC];				 /** Poids de chaque classe c */
int		 R[maxC];				 /** Nombre d'infirmieres de la classe c */
int		 T[maxC];				 /** Ensemble des periodes de presences des infirmieres de la classe */
 
float	 ratio_presence = 0.3;	 /**< ratio de presence des postes difficiles par periodes H[t] */
int		 Tab_Presence[maxR];
int		 somme_periods;
int		 Table_Periods[maxR];
 
FILE *fp=NULL;
 
ofstream outapp;	/**< output single line reports */
ofstream outsol;	/**< output complete solution */
 
/************* random number generators ****************/
 
const long m = 2147483647; const long m2 = 2145483479;
const long a12 = 63308; const long q12 = 33921; const long r12 = 12979;
const long a13 = -183326; const long q13 = 11714; const long r13 = 2883;
const long a21 = 86098; const long q21 = 24919; const long r21 = 7417;
const long a23 = -539608; const long q23 = 3976; const long r23 = 2071;
const double invm = 4.656612873077393e-10;
long x10 = 12345, x11 = 67890, x12 = 13579, x20 = 24680, x21 = 98765, x22 = 43210;
 
long unif(long low, long high)
{
	return (low + rand()%(high-low+1));
}
 
void loadinstance(char* filename);
void generateInstance(int seed,char* filename);
 
//---------------------*
//      main
//---------------------*
 
int main (int argc,char** argv)
{
	int r,t,c,p;
	int seed;
	char filename[256];		 filename[0]='\0';
	char outappname[256];	 outappname[0]='\0';  
	char outsolname[256];	 outsolname[0]='\0'; 
 
	p=1;
	bool load=false;
	//srand(time(NULL));
 
	while (p < argc)
	{
        if (!strcmp(argv[p],"-generate"))	// generate an instance
		{
			strcpy(filename,argv[p+1]);
			p++;
		}
		else if(!strcmp(argv[p],"-nr"))		// generate the number of the resources
		{
			nr=atoi(argv[p+1]);
			p++;
		}
		else if(!strcmp(argv[p],"-dm"))		// generate the number of the periods
		{
			dm=atoi(argv[p+1]);
			p++;
		}
		else if(!strcmp(argv[p],"-seed"))		// generate the seed
		{
			seed=atoi(argv[p+1]);
			srand(seed); // initialisation de rand
			p++;
		}
		else if (!strcmp(argv[p],"-load"))	// load and solve an instance
		{
			strcpy(filename,argv[p+1]);
			load=true;
			p++;
		}
		else if (!strcmp(argv[p],"-outapp"))	// single line outpout
		{
			strcpy(outappname,argv[p+1]);
			p++;
		}
		else if(!strcmp(argv[p],"-outsol"))		// solution output
		{
			strcpy(outsolname,argv[p+1]);
			p++;
		}
	p++;
    }
 
	#ifdef TRACE1		
	cout<<"\n nr "<<nr<<" dm "<<dm<<" filename "<<filename<<" seed "<<seed<<" outsol "<<outsolname<<" outapp "<<outappname<<endl;
	#endif
 
	if(load)
		loadinstance(filename);
	else
	{
		generateInstance(seed,filename);
  		return 1;
	}
 
	IloEnv env;
    // ouvrir le fichier en mode append pour stocker tous les resultats des differentes instances
 
    outapp.open (outappname, ios::out | ios::app);
    outsol.open (outsolname, ios::out);
 
 
	stringstream buffer;
	string nom;
	// try qui permet de rattraper les erreurs renvoyees par cplex
 
	try 
	{
		start1 = time(NULL);
	    // Declaration du modele.
 
		IloModel mdl1(env);
		IloArray<IloIntVarArray> N(env);	   // 2 dimensions
		IloIntVarArray W(env);				   // 1 seule dimension
		IloNumVar Z(env);					   // sans dimension : Objectif
 
		// VARIABLES DE DECISIONS : V booléennes
 
		// N[c][t] : Variable entiere : Nombre total des postes difficiles affectes a la classe c
 
		for(c=0;c<nclasses;c++)		// boucle sur le nombre de classes 
		{    
			N.add(IloIntVarArray(env));
			for(t=0;t<dm;t++)		// boucle sur le nombre de taches
			{
				N[c].add(IloIntVar(env));
				stringstream buffer;
				buffer<<"N["<<c<<"]["<<t<<"]";
				nom=buffer.str();
				N[c][t].setName(nom.c_str());
				mdl1.add(N[c][t]);
			}
		}
 
		// W[c] : nombre de postes difficiles par classe c.s
 
		for(c=0;c<nclasses;c++)		// boucle sur le nombre de classes 
		{
			W.add(IloIntVar(env));
			stringstream buffer;
			buffer<<"W["<<c<<"]";
			nom=buffer.str();
			W[c].setName(nom.c_str());				
			mdl1.add(W[c]);
		}
 
 
		/*------------------------------------------------------------*
		                         Fonction objectif
		*-------------------------------------------------------------*/
		IloExpr sub(env);
 
		// Minimiser le nombre de jours difficile
 
		sub+= Z;
 
		mdl1.add(IloMinimize(env,sub));
 
		/*-----------------------------------------------------------*
								Contraintes
		*-----------------------------------------------------------*/
 
		// Contrainte n15.
 
		for(c=0;c<nclasses;c++)
		{
			IloExpr ex15(env);
			ex15 = Z;
			ex15 = ex15 - (W[c]/P[c]);
			IloRange rng = (ex15 >= 0);
			stringstream buffer;
			buffer<<" Contrainte_numero_15_ "<<c<<"_"<<endl; 
			rng.setName(buffer.str().c_str());
			mdl1.add(rng);
			ex15.end();
		}
 
		// contrainte numero 16.
		for(c=0;c<nclasses;c++)
		{
			IloExpr ex16(env);
			ex16 = W[c];
			for(t=0;t<dm;t++)
			{
				ex16 -= (N[c][t]/R[c]);
			}
			IloRange rng = (ex16 >= 0 );
			stringstream buffer;
			buffer<<" Contrainte_numero_16_ "<< c <<"_"<<endl; 
			rng.setName(buffer.str().c_str());
			mdl1.add(rng);
			ex16.end();
		}
 
		// contrainte numero 17.
 
		for(t=0;t<dm;t++)
		{
			IloExpr ex17(env);
			for(c=0;c<nclasses;c++)
			{
				ex17 = ex17 + N[c][t];
			}
			IloRange rng = (ex17 == H[t]);
			stringstream buffer;
			buffer<<" Contrainte_numero_17_ "<< t <<"_"<<endl;
			rng.setName(buffer.str().c_str());
			mdl1.add(rng);
			ex17.end();
		}
 
		// contrainte numero 18.
 
		for(t=0;t<dm;t++)
		{
			for(c=0;c<nclasses;c++)
			{
				IloExpr ex18(env);
				ex18 = N[c][t];
				IloRange rng = (ex18 <= R[c]);
				stringstream buffer;
				buffer<<" Contrainte_numero_18_ "<< t << " " << r << endl; 
				rng.setName(buffer.str().c_str());
				mdl1.add(rng);
				ex18.end();
			}
		}
 
		/* *************************** */
 
		IloCplex cplex(env);
		cplex.extract(mdl1);
		cplex.setParam(IloCplex::SimDisplay,1);
		// WorkMem parameter
		cplex.setParam(IloCplex::WorkMem, 5000);
 
		#ifdef TRACE1		
		cplex.setParam(IloCplex::SimDisplay,1);
		cplex.exportModel("model.lp");
		#endif
 
		// Mesure du temps d'exécution des programmes
		#ifdef WIN64
		 // Variables
		ULARGE_INTEGER tbegin,tend;
		FILETIME ttmp={0,0};                    // temporary variable
		double texec=0;
 
		// Start timer
		::GetSystemTimeAsFileTime(&ttmp);       // store current time in ttmp structure
		tbegin.HighPart=ttmp.dwHighDateTime;    // convert ttmp to two int32
		tbegin.LowPart=ttmp.dwLowDateTime;
		#endif
		cplex.setParam(IloCplex::TiLim,100);
		cplex.setParam(IloCplex::TreLim,3000);
		cout<<"\n Avant la resolution cpu : "<<difftime(time(NULL),start1)<<"\n"<<endl;
		start1 = time(NULL);
		bool findsol = cplex.solve();
		end1=time(NULL);
		cout<<"\n Apres la resolution ";
 
		if(!findsol)
		{
			if(cplex.getStatus()==IloAlgorithm::InfeasibleOrUnbounded || cplex.getStatus()==IloAlgorithm::Infeasible || cplex.getStatus()==IloAlgorithm::Unbounded)
			{
				#ifdef TRACE1
				cout<<" \n INFAISABLE cpu "<<difftime(end1,start1)<<" cplex.getStatus() "<<cplex.getStatus()<<endl;
				#endif
				return 1;
			}
			else
			{
				cout<<" \n PAS DE SOLUTION TROUVEE : cpu "<<difftime(end1,start1)<<" cplex.getStatus() "<<cplex.getStatus()<<endl;
				return 1;
			}
		}
		else
		{
			//  START IF cplex.solve()
			#ifdef TRACE1
			cerr << "\n Objective Value = " << cplex.getObjValue() <<" "<<cplex.getStatus()<<" "<<cplex.getCplexStatus()<<" gap "<<cplex.getMIPRelativeGap()<<" bsup "<<cplex.getObjValue()<<" binf "<<cplex.getBestObjValue()<<endl;
			#endif
		}
 
		// Affichage des variables de decisions
 
		for (r=0; r<nr; r++)
		{
			cerr<< " variable W ["<< r <<"] = " << cplex.getValue(W[r]) << endl;
		}
 
		// end if cplex.solve()
 
		#ifdef WIN64
		// End timer
		::GetSystemTimeAsFileTime(&ttmp);       // store current time in ttmp structure
		tend.HighPart=ttmp.dwHighDateTime;      // convert ttmp to two int32
		tend.LowPart=ttmp.dwLowDateTime;
 
		// Compute execution time
		texec=((double)((tend.QuadPart-tbegin.QuadPart)/10000))/1000.;
		std::cout << "Execution time : " << texec << " "<<difftime(end1,start1) << endl;
		#endif
 
 
		// Affichage des variables de decisions
 
		for (c=0; c<nclasses; c++)
		{
			for(t=0;t<dm;t++)
			{
				#ifdef TRACE1
				cerr<< " variable N ["<< c <<"]["<< t << "] = " << cplex.getValue(N[c][t]) << endl;
				#endif
			}
		}
 
		outapp<<nr<<"\t"<<dm<<"\t"<<cplex.getObjValue()<<"\t"<<cplex.getObjValue()<<"\t"<<cplex.getBestObjValue()<<"\t"<<cplex.getMIPRelativeGap()<<"\t"<<difftime(end1,start1)<<"\t"<<endl;
		}
		catch (IloException& e) 
		{
		  cerr << " Concert Exception caught: " << e << endl;
		}
		catch (...) 
		{
			cerr << "Error: Unknown exception caught" << endl;
		}
		env.end();
		outapp.close();
		outsol.close();
		return 0;
 
}	//END MAIN
 
void generateInstance(int seed, char* filename )
{
	int r,t,k,i,c,j;
	int variable_presence;
 
	srand(time(NULL));
 
	/* construire la matrice de presence du personnel sur l'horizon */
	for(r=0; r<nr; r++) // nombre de ressources 
	{
		for(t=0; t<dm; t++) // nombre de periodes
		{
			Q[r][t]=rand()%2;
		}
	}
 
	/* ensemble des infirmieres de chaque classe c */
 
	std::map<int, int> tokens;
	typedef std::vector<int> row;
	std::vector<row> myClasses;
	for(i = 0 ; i<nr ;i++)
	{
		int key = 0;
		for(j = 0 ; j<dm ;j++)
		{
		  key += Q[i][j] << j;
		  cerr << " key " << key << " j " << j << endl;
		}
		if(tokens.find(key) == tokens.end())
		{
		  myClasses.push_back(row(1,i));
		  tokens[key] = myClasses.size()-1;
		}
		else
			{
				myClasses[tokens[key]].push_back(i);
				}
	}
 
	/* generer les periodes de prensence du personnel */
	for (r=0;r<nr;r++)
	{
		somme_periods = 0;
		i=0;
		for (t=0; t<dm; t++)
			if (Q[r][t]==1)
				Tab_Presence[i++]=t;
		//cerr<< "ressource " << r << " : ";
		for (k=0; k<i;k++)
		{
			somme_periods += Tab_Presence[k];
			//cerr <<Tab_Presence[k] <<'\t';
			}
		Table_Periods[r] = somme_periods;
		//cerr << " somme " << somme_periods << " Test " << Table_Periods[r] << endl;
		//cerr<< endl;
	}
 
	/* Calcul du nombre de jours de presence de chaque infirmiere */
	int Tab_Pre_Per[maxR];
	for (r=0;r<nr;r++)
	{
		Tab_Pre_Per[r]=0;
		for (t=0; t<dm; t++)
			if (Q[r][t]==1)
				Tab_Pre_Per[r] +=1;
		//cerr<< "ressource " << r << " : " <<Tab_Pre_Per[r]<< endl;
	}
 
	/* Calcul du poids pour chaque ressource */
	for(c=0;c<nclasses;c++)
	{
		P[c] = Tab_Pre_Per[c];
		//cerr <<"poids classe : "<< c << " = " << P[c] << "\n";
	}
 
	/* Vecteur de nombres de jours difficiles */ // ==> OK
	double ratio_presence = 0;
	int nombre_maximale_H = 6; // rand()%nr
	int nombre_minimale_H = 3;
	for(t=0; t<dm; t++)
	{
		if (rand()%dm<ratio_presence*dm)
			H[t] = 0;
		else
			H[t]=rand()%(nombre_maximale_H - nombre_minimale_H) + nombre_minimale_H;
	}
 
	cerr<<"\n **** fichier generate **** "<<endl;	
	ofstream fp (filename);
	// tester l'ouverture du fichier texte
    if (!fp.is_open())
	cerr << "Cannot write into "<< filename << endl;
	else
	{
		/****** instance  ******/
		fp<<nr <<" "; // nombre de ressources
		fp<<dm <<" "; // nombre de periodes
		fp<<"\n";
		fp<<"\n";
		fp<<"matrice presence" << endl;
		fp <<"\n";
		for(r=0; r<nr; r++)
		{
			for(t=0; t<dm; t++)
			{
				fp<< Q[r][t] << "\t" ;
			}
			fp<<"\n";
		}
		fp <<"\n";
		fp<<"poids infirmiers" << endl;
		fp <<"\n";
		for (r=0;r<nr;r++)
		{
			fp <<P[r]<<"\t";
		}
		fp <<"\n";
		fp <<"\n";
		fp<<"vecteur periode" << endl;
		fp <<"\n";
		for(t=0; t<dm; t++)
		{
			fp <<H[t]<<"\t";
		}
		fp <<"\n";
		fp <<"\n";
		fp<<"classe infirmieres" << endl;
		fp <<"\n";
		for (c=0;c<nclasses;c++)
		{
			fp <<R[c]<<"\t";
		}
 
 
		//fp<<"presence periods" << endl;
		//fp <<"\n";
		//for (r=0;r<nr;r++)
		//{
		//   i=0;
		//   for (t=0; t<dm; t++)
		//	  if (matrice_presence[r][t]==1)
		//		   Tab_Presence[i++]=t;
		// //  fp<< "" << r << "";
		//   for (k=0; k<i;k++)
		//	   fp <<Tab_Presence[k] << '\t';
		//   fp<< endl;
		//}
	}
}
 
void loadinstance(char* filename)
{
	int r,t;
	ifstream fp (filename);
 
	// tester l'ouverture du fichier texte
	if (!fp.is_open())
	cerr << "\n Cannot read "<< filename << endl;
	else
	{
		char buf[256];
		char bufc;
		fp>>nr;     // nombre de ressources
		cerr <<""<< nr ;
		fp>>dm;     // nombre de periodes
		cerr <<" "<< dm ;
		cerr <<"\n" ;
		// matrice presence
		fp>>buf;
		cerr <<""<< buf ;
		fp>>buf;
		cerr <<" "<< buf ;
		cerr <<"\n" ;
		for(r=0; r<nr; r++)
		{
			for(t=0; t<dm; t++)
			{
				fp >>  Q[r][t];
				cerr << Q[r][t] <<"\t";
			}
			cerr <<"\n" ;
		}
 
		// poids infirmiers
		fp>>buf;
		cerr <<""<< buf ;
		fp>>buf;
		cerr <<" "<< buf ;
		cerr <<"\n" ;
		for(r=0; r<nr; r++)
		{
			fp >> P[r] ;
			cerr << P[r] <<"\t";
		}
		cerr <<"\n" ;
		cerr <<"\n" ;
		// vecteur periode
		fp>>buf;
		cerr <<""<< buf ;
		fp>>buf;
		cerr <<" "<< buf ;
		cerr <<"\n" ;
		for(t=0; t<dm; t++) 
		{
			fp >>  H[t];
			cerr << H[t] << " \t";
		}
 
		//// presence periods
		//fp>>buf;
		//cerr <<""<< buf ;
		//fp>>buf;
		//cerr <<" "<< buf ;
		//cerr <<"\n" ;
		//for(r=0; r<nr*dm; r++)
		//{
		//	fp >>  buf;
		//	cerr << buf <<"\n";
		//}
		//cerr <<"\n" ;
	}
}

Merci à vous :)

24/11/2014, 11h23
bacelar

Mon langage est peut-être un peu vert mais les codes qui j'ai fourni sont opérationnels (avec ou sans tableaux de m....).
Je pense que le problème du code de galerien69, c'est qu'il utilise une map et non une multimap.
A la rigueur, utilisez une std::map<int,std::list<int>> à la place d'une multimap.

pourriez-vous m'expliquer comment afficher le résultat du vecteur svp ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
std::map<int, int> tokens;
	typedef std::vector<int> row;
	std::vector<row> myClasses;
	for(i = 0 ; i<nr ;i++)
	{
		int key = 0;
		for(j = 0 ; j<dm ;j++)
		{
		  key += Q[i][j] << j;
		}
		if(tokens.find(key) == tokens.end())
		{
		  myClasses.push_back(row(1,i));
		  tokens[key] = myClasses.size()-1;
		}
		else
			{
				myClasses[tokens[key]].push_back(i);
				}
	}
 
	for (i = 0; i < myClasses.size(); i++)
	{
		std::cerr << tokens[i] << std::endl;
	}

Merci.

24/11/2014, 16h40
ternel

bah "pour (tout élément du vecteur, du premier au dernier) {afficher l'élément; afficher un séparateur}"
24/11/2014, 18h10
Student_Master

Citation:

bah "pour (tout élément du vecteur, du premier au dernier) {afficher l'élément; afficher un séparateur}"

Je ne suis pas arrivé à le faire. Car je ne comprends pas les vecteurs.
25/11/2014, 11h29
ternel
En ce cas, poses-toi alors la bonne question: "qu'est ce qu'un vecteur?", plutot que "puis-je avoir un code tout fait?".

std::vector<Truc> est (un cas particulier de la template d') une classe qui propose une fonctionnalité précise.
C'est un conteneur (ou collection) ordonnée, à accès direct, et redimensionnable.

Cela signifie trois choses:
1. on peut accéder aux données comme avec un tableau, par leur index.
2. on peut ajouter et supprimer des éléments, changeant la taille du tableau.
3. on peut le manipuler comme toute collection: par un itérateur, qui possède au moins les fonctionnalités ++it et *it.
Le premier point se traduit directement par l'operateur [], identique à celui d'un tableau. Et aussi at(int), qui vérifie que l'index soit valable.

Le second par push_back(element) qui ajoute (une copie de) l'élément à la fin du tableau, augmentant sa taille.
Tu trouveras aussi push_front(element), pop_back(element), pop_front(element).

Le troisième point correspond à begin() et end().

Pour avoir du code, regarde donc soit notre faq, soit une référence du langage (comme celle-ci)

Bonjour,
J'ai essayé un truc dans le genre :
Code:

1 2 3 4 5 6 map<int,int>::iterator iter; for(iter=tokens.begin(); iter!=tokens.end(); ++iter) { cout<<"cle: "<< iter->first <<", valeur: "<< iter->second<<endl; }
Il m'affiche le résultat suivant :
Code:

1 2 3 4 5 6 7 clé: 377, valeur: 1 clé: 419, valeur: 5 clé: 518, valeur: 2 clé: 689, valeur: 3 clé: 771, valeur: 6 clé: 783, valeur: 4 clé: 949, valeur: 0
Ce n'est pas le résultat que je m'attendais.
Merci à vous :)

26/11/2014, 13h12
ternel
Par contre, c'est bien le contenu de cette map.
Du coup, il faut regarder à l'autre bout du problème.

Quand un résultat n'est pas le bon, il n'y a que trois possibilités:
- on ne regarde pas la bonne chose (erreur d'affichage),
- on n'a pas correctement fais le traitement,
- on n'a pas utilisé les bonnes données.
Si tu es certain que c'est tokens qui contient ton résultat, tu n'es pas dans le premier cas.
J'en déduis que ta map ne contient effectivement pas ce que tu veux.

Donc soit les données d'entrées ne sont pas celles que tu croies, soit c'est le traitement qui n'est pas bon.
26/11/2014, 14h36
bacelar

A ça, pour mettre des pouces rouges y a du monde, mais pour sortir le newbie de l'ornière où il s'est mis parce qu'un professeur dinosaure n'a pas revu son cours depuis 25 ans, y a plus grand monde. :scarymov:

Regardez le code que j'ai posté.

Dans la variable "myvector", il y a tout ce dont vous avez besoin, de manière simple et accessible.

C'est cool, on me colle des pouces rouges et on me fait des remarques condescendantes mais personne ne prend la peine de lire mon post.

Tirésias, mon cu, je suis pas Cassandre.
26/11/2014, 15h04
Student_Master
Bref, j'ai essayé d'utiliser ton code mais j'ai un problème de compilation :

Code:

compiler support c++11 ranged for syntax

.
Si tu peux changer cette partie :
Code:

1 2 3 4 5 6 7 8 9 10 11 int ligne = 0; for( const auto& i : myvector ) // i { int colone = 0; for( auto j : i) // j : i { R[ligne*maxCardinalite+colone] = j; // i colone++; } ligne++; }
Et de m'afficher le résultat ça serait génial de votre part. Comme ça, je résout mon problème qui m'as pris du temps. Merci à vous tous.

Citation:

Envoyé par Student_Master

Bref, j'ai essayé d'utiliser ton code mais j'ai un problème de compilation :

Code:

compiler support c++11 ranged for syntax

.

Ca, c'est parce que le code utilise une syntaxe qui est apparue avec la norme C++11...
Citation:
Si tu peux changer cette partie :
Code:

1 2 3 4 5 6 7 8 9 10 11 int ligne = 0; for( const auto& i : myvector ) // i { int colone = 0; for( auto j : i) // j : i { R[ligne*maxCardinalite+colone] = j; // i colone++; } ligne++; }
Et de m'afficher le résultat ça serait génial de votre part. Comme ça, je résout mon problème qui m'as pris du temps. Merci à vous tous.
Mieux encore, si tu peux activer le support de C++11 et faire en sorte que ton compilateur supporte cette syntaxe, cela t'ouvrira l'accès à toutes les fonctionnalités de C++11, et tu ne t'en portera que mieux à la longue ;)

On peut activer le support de c++11 sous clang et gcc en ajoutant l'option -std=c++11 à la commande de compilation.

Si tu utilises un EDI, tu dois allez voir du coté des options de compilation pour activer cette possibilité. Par exemple, sous code::blocks, cela se fait au niveau du menu Project ->build options ->dans l'onglet "compiler flags" de l'onglet "compiler settings" (c'est celui qui est affiché par défaut), cocher la case "have g++ to follow the C++11 ISO C++language". Dans qtcreator, cela se fait en rajoutant la ligne QMAKE_CXXFLAGS += -std=c++11 au fichier .pro

Maintenant, si tu ne peux vraiment pas utiliser C++11 (par exemple parce que ton compilateur est trop ancien), cette syntaxe peut être remplacée par une boucle pour classique :
Code:

1 2 3 4 5 6 7 8 9 /*version "C++11*/ for( int /* ou auto */i :tableau){ /* manipuler i qui correspond à chaque élément du tableau, les uns apres les autres */ } /* version "pré C++11"*/ for(size_t count = 0; count <tableau.size();++count){ int i = tableau[i]; /* manipuler i qui correspond à chaque élément du tableau, les uns apres les autres */ }
Tu devrais donc presque pouvoir modifier le code par toi même ;)

Citation:

Envoyé par koala01

Par exemple, sous code::blocks

Merci pour ta réponse. Je travaille sous Visual Studio 2010. Est ce qu'il y a un moyen de l'activer ?
voici le code après modification :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 int ligne = 0; for(size_t count = 0; count <myvector.size(); ++count) // i { int i = myvector.size(); int colone = 0; for( size_t count = 0; count <i; ++count) // j : i { int j=i; R[ligne*maxCardinalite+colone] = j; // i colone++; } ligne++; }
merci.

26/11/2014, 18h27
bacelar

VS2010 est sorti en l'an de grâce 2010, la norme C++11 est sortie en 2011, malheureusement.

VS2010 support pas mal de fonctionnalités qui ont été ajoutées au C++11, mais à cette époque, ce n'étaient que des TR (Technical Report) avec des noms définitifs.

Je pense qu'il serait nettement plus rentable de migrer vers VS2013, même en Express plutôt que d'activer le support de ces TR ou d'aller à la recherche de VS Update hypothétiques.

Si vous êtes tanqué sous VS2010, vous savez comment convertir un "ranged for" de C++11 en boucle "for i" du C++tout vieux. ;)

Si vous pouvez éviter d'utiliser cette horreur de tableau "R" et n'utiliser que "myvector", je dormirai mieux (et vous aurez bien moins d'emmerdes :aie: ).