锘??xml version="1.0" encoding="utf-8" standalone="yes"?>
#include聽
<
stdlib.h
>
#include聽
<
string
.h
>
#define
聽N聽5001
struct
聽Node
{
聽聽聽聽
int
聽length;
聽聽聽聽
int
聽weight;
};
int
聽n;
Node聽d[N];
bool
聽visite[N];
int
聽cmp(聽
const
聽
void
*
聽a,聽
const
聽
void
*
聽b聽)
{
聽聽聽聽Node
*
聽ta
=
聽(Node
*
)a;
聽聽聽聽Node
*
聽tb
=
聽(Node
*
)b;
聽聽聽聽
聽聽聽聽
if
(聽ta
->
length
==
聽tb
->
length聽)聽
return
聽ta
->
weight
-
聽tb
->
weight;
聽聽聽聽
聽聽聽聽
return
聽ta
->
length
-
聽tb
->
length;
}
int
聽main()
{
聽聽聽聽
int
聽test;
聽聽聽聽scanf(
"
%d
"
,聽
&
test);
聽聽聽聽
聽聽聽聽
while
(聽test
--
聽)
聽聽聽聽{
聽聽聽聽聽聽聽聽scanf(
"
%d
"
,聽
&
n聽);
聽聽聽聽聽聽聽聽
for
(聽
int
聽i
=
聽
0
;聽i
<
聽n;聽
++
i聽)
聽聽聽聽聽聽聽聽scanf(
"
%d%d
"
,聽聽聽聽聽
&
d[i].length,聽
&
d[i].weight聽);
聽聽聽聽聽聽聽聽
聽聽聽聽聽聽聽聽qsort(聽d,聽n,聽
sizeof
(d[
0
]),聽cmp聽);
聽聽聽聽聽聽聽聽memset(聽visite,聽
false
,聽
sizeof
(visite)聽);
聽聽聽聽
聽聽聽聽聽聽聽聽
int
聽b
=
聽d[
0
].weight;
聽聽聽聽聽聽聽聽
int
聽num
=
聽
0
;
聽聽聽聽聽聽聽聽
int
聽k
=
聽
0
;
聽聽聽聽聽聽聽聽
聽聽聽聽聽聽聽聽
while
(聽
true
聽)
聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽
bool
聽ok
=
聽
false
;
聽聽聽聽聽聽聽聽聽聽聽聽
聽聽聽聽聽聽聽聽聽聽聽聽
if
(聽k
==
聽
-
1
聽)聽
break
;
聽聽聽聽聽聽聽聽聽聽聽聽b
=
聽d[k].weight;聽聽聽num
++
;
聽聽聽聽聽聽聽聽聽聽聽聽
聽聽聽聽聽聽聽聽聽聽聽聽
int
聽be
=
聽k;聽聽k
=
聽
-
1
;
聽聽聽聽聽聽聽聽聽聽聽聽
聽聽聽聽聽聽聽聽聽聽聽聽
for
(聽
int
聽i
=
聽be;聽i
<
聽n;聽
++
i聽)
聽聽聽聽聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
if
(聽d[i].weight
>=
聽b聽
&&
聽
!
visite[i]聽)
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽visite[i]
=
聽
true
;
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽b
=
聽d[i].weight;
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
else
聽
if
(聽
!
ok聽
&&
聽
!
visite[i]聽)聽聽聽{聽聽聽k
=
聽i;聽聽ok
=
聽
true
;聽聽}
聽聽聽聽聽聽聽聽聽聽聽聽}聽
聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽
聽聽聽聽聽聽聽聽printf(
"
%d\n
"
,聽num聽);
聽聽聽聽}
聽聽聽聽
聽聽聽聽
return
聽
0
;
}
]]>
#include聽
<
iostream
>
#include聽
<
set
>
#include聽
<
limits
>
using
聽
namespace
聽std;
struct
聽Node
{
聽聽聽聽
int
聽broad,聽price;
聽聽聽聽Node()
{}
聽聽聽聽Node(
int
聽
&
a,
int
&
b)
聽聽聽聽聽聽聽聽:broad(a),price(b)
聽聽聽聽
{}
}
;
Node聽data[
100
][
100
];
int
聽聽length[
100
];

int
聽main()
{
聽聽聽聽
int
聽test;
聽聽聽聽scanf(
"
%d
"
,
&
test);
聽聽聽聽
while
(聽test
--
聽)
聽聽聽聽
{
聽聽聽聽聽聽聽聽
int
聽n;
聽聽聽聽聽聽聽聽
set
<
int
>
聽br;
聽聽聽聽聽聽聽聽scanf(
"
%d
"
,
&
n);
聽聽聽聽聽聽聽聽
for
聽(聽
int
聽i
=
聽
0
;聽i
<
聽n;聽
++
i聽)
聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽
int
聽d,x,y;
聽聽聽聽聽聽聽聽聽聽聽聽scanf(
"
%d
"
,
&
d);
聽聽聽聽聽聽聽聽聽聽聽聽length[i]
=
聽d;
聽聽聽聽聽聽聽聽聽聽聽聽
for
聽(聽
int
聽j
=
聽
0
;聽j
<
聽d;聽
++
j聽)
聽聽聽聽聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf(
"
%d%d
"
,
&
x,
&
y);
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽data[i][j]
=
聽Node(x,y);
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽br.insert(x);聽聽聽聽
//
聽聽聽Save聽all聽broad聽,聽use聽set聽to聽avoid聽repeating
聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽
set
<
int
>
::iterator聽pos;
聽聽聽聽聽聽聽聽
double
聽max
=
聽numeric_limits
<
double
>
::min();
聽聽聽聽聽聽聽聽
for
聽(聽pos
=
聽br.begin聽();聽pos
!=
聽br.end聽();聽
++
pos聽)聽聽聽
//
聽聽聽for聽every聽broad
聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽
int
聽聽聽t
=
聽
*
pos;
聽聽聽聽聽聽聽聽聽聽聽聽
int
聽聽聽total
=
聽
0
;
聽聽聽聽聽聽聽聽聽聽聽聽
bool
聽聽isok
=
聽
false
;
聽聽聽聽聽聽聽聽聽聽聽聽
for
聽(聽
int
聽i
=
聽
0
;聽i
<
聽n;聽
++
i聽)聽聽聽
//
聽聽n聽devices
聽聽聽聽聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
int
聽M
=
聽INT_MAX;
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
for
聽(聽
int
聽j
=
聽
0
;聽j
<
聽length[i];聽
++
j聽)
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
if
聽(聽data[i][j].broad
>=
聽t聽
&&
聽data[i][j].price
<
聽M聽)
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽M
=
聽data[i][j].price;聽聽聽聽聽聽
//
聽聽聽find聽聽the聽min聽price
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
if
聽(聽M
==
聽INT_MAX聽)
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽isok
=
聽
true
;
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
break
;
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽total
+=
聽M;聽聽聽聽聽
聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽聽聽聽聽
if
聽(聽isok聽)聽
continue
;
聽聽聽聽聽聽聽聽聽聽聽聽
if
聽(聽(
double
)t
/
聽(
double
)total
>
聽max聽)聽max
=
聽(
double
)t
/
聽(
double
)total;聽聽聽
//
聽聽update
聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽printf(
"
%.3lf\n
"
,聽max聽);
聽聽聽聽}
聽聽聽聽
return
聽
0
;
}
#include聽
<
iostream
>
using
聽
namespace
聽std;
int
聽聽d[
6
];
bool
聽isok
=
聽
false
;
int
聽聽total
=
聽
0
;
void
聽Try(聽
int
聽i,聽
int
聽total聽)
{
聽聽聽聽
if
聽(聽total
==
聽
0
聽)
聽聽聽聽
{
聽聽聽聽聽聽聽聽isok
=
聽
true
;
聽聽聽聽聽聽聽聽
return
;
聽聽聽聽}
聽聽聽聽
if
聽(聽i
<
聽
0
聽)聽
return
;
聽聽聽聽
for
聽(聽
int
聽j
=
聽d[i];聽j
>=
聽
0
;聽j
--
聽)
聽聽聽聽
{
聽聽聽聽聽聽聽聽
if
聽(聽isok聽)聽
break
;
聽聽聽聽聽聽聽聽
if
聽(聽total
-
聽j
*
聽(i
+
聽
1
)
>=
聽
0
聽
&&
聽
!
isok聽)
聽聽聽聽聽聽聽聽聽聽聽聽Try(聽i
-
聽
1
,聽total
-
聽j
*
(i
+
聽
1
)聽);
聽聽聽聽}
}
int
聽main()
{
聽聽聽聽
int
聽num
=
聽
1
;
聽聽聽聽
while
(聽scanf(
"
%d%d%d%d%d%d
"
,聽d
+
聽
0
,聽d
+
聽
1
,聽d
+
聽
2
,聽d
+
聽
3
,聽d
+
聽
4
,聽d
+
聽
5
聽),
聽聽聽聽聽聽聽聽聽聽聽d[
0
]
+
聽d[
1
]
+
聽d[
2
]
+
聽d[
3
]
+
聽d[
4
]
+
聽d[
5
]
!=
聽
0
聽)
聽聽聽聽
{
聽聽聽聽聽聽聽聽total
=
聽
0
;
聽聽聽聽聽聽聽聽
for
聽(聽
int
聽i
=
聽
0
;聽i
<
聽
6
;聽
++
i聽)
聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽d[i]
%=
聽
60
;
聽聽聽聽聽聽聽聽聽聽聽聽total
+=
聽(i
+
1
)
*
聽d[i];
聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽
if
聽(聽total
&
聽
1
聽)
聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽printf(
"
Collection聽#%d:\n
"
,num
++
);
聽聽聽聽聽聽聽聽聽聽聽聽printf(
"
Can't聽be聽divided.\n
"
);
聽聽聽聽聽聽聽聽聽聽聽聽printf(
"
\n
"
);
聽聽聽聽聽聽聽聽聽聽聽聽
continue
;
聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽isok
=
聽
false
;
聽聽聽聽聽聽聽聽Try(聽
5
,聽total
/
聽
2
聽);
聽聽聽聽聽聽聽聽printf(
"
Collection聽#%d:\n
"
,num
++
);
聽聽聽聽聽聽聽聽
if
聽(聽
!
isok聽)聽聽聽聽聽聽聽聽
聽聽聽聽聽聽聽聽聽聽聽聽printf(
"
Can't聽be聽divided.\n
"
);
聽聽聽聽聽聽聽聽
else
聽聽聽聽聽聽聽聽聽聽聽聽printf(
"
Can聽be聽divided.\n
"
);
聽聽聽聽聽聽聽聽printf(
"
\n
"
);
聽聽聽聽}
聽聽聽聽
return
聽
0
;
}