File size: 181,961 Bytes
aff484f | 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 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 | task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
CVRP,CVRP,"Someone from the store is lining up the drivers and thinking about how to split the work: every driver should start at the shop, cover a set of houses with their requested groceries exactly once, and return to the shop without exceeding the van’s load limit. To pick the best way, add up the distance each van travels and choose the arrangement with the smallest total distance. The concrete list of stops, quantities, and van capacities follows below.
There are 11 locations in total; the shop is node A, and each van can carry up to 100 units.
| location_id | location_x_coordinate | location_y_coordinate | grocery_demand_units |
|---|---|---|---|
| A | 87 | 24 | 0 |
| B | 8 | 13 | 23 |
| C | 84 | 43 | 12 |
| D | 0 | 52 | 19 |
| E | 55 | 100 | 19 |
| F | 88 | 43 | 17 |
| G | 61 | 39 | 8 |
| H | 0 | 98 | 12 |
| I | 97 | 31 | 18 |
| J | 100 | 6 | 18 |
| K | 84 | 0 | 21 |
Assign routes so each van starts and ends at node A, never exceeds 100 units, and the overall distance is minimized.
Also, to keep things tidy, when you send back the routes just stick to a simple JSON shape like this so I can read it straight away:
{
""solution"": [[shop_id, house_id, ... , shop_id], [shop_id, house_id, ... , shop_id], ...]
}
Pretty much: ""solution"" is a list of routes; each route is an array that starts and ends with the shop_id and lists the houses (house_id) visited in order. It's just an example of the shape I expect—don't treat these placeholders as real answers.
Please use the exact identifiers from the instance input — no renaming and no made-up labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[87, 24], [8, 13], [84, 43], [0, 52], [55, 100], [88, 43], [61, 39], [0, 98], [97, 31], [100, 6], [84, 0]], 'depot': 0, 'demands': [0, 23, 12, 19, 19, 17, 8, 12, 18, 18, 21], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 413.5678875431946, 'objective': 413.5678875431946}","[[0, 10, 9, 8, 5, 0], [0, 6, 1, 3, 7, 4, 2, 0]]",413.5678875431946,"{'problem_type': 'CVRP', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 87, 'y': 24, 'demand': 0}, {'id': 'B', 'x': 8, 'y': 13, 'demand': 23}, {'id': 'C', 'x': 84, 'y': 43, 'demand': 12}, {'id': 'D', 'x': 0, 'y': 52, 'demand': 19}, {'id': 'E', 'x': 55, 'y': 100, 'demand': 19}, {'id': 'F', 'x': 88, 'y': 43, 'demand': 17}, {'id': 'G', 'x': 61, 'y': 39, 'demand': 8}, {'id': 'H', 'x': 0, 'y': 98, 'demand': 12}, {'id': 'I', 'x': 97, 'y': 31, 'demand': 18}, {'id': 'J', 'x': 100, 'y': 6, 'demand': 18}, {'id': 'K', 'x': 84, 'y': 0, 'demand': 21}], 'depot': 'A', 'capacity': 100, 'num_vehicles': 2, 'total_distance': 413.5678875431946, 'objective': 413.5678875431946}","[['A', 'K', 'J', 'I', 'F', 'A'], ['A', 'G', 'B', 'D', 'H', 'E', 'C', 'A']]",1,markdown_table,names
CVRP,CVRP,"We’re coordinating the day’s routes so a handful of carriers can hand over every piece of mail one time and then return to the post office. The choice is which streets and houses each carrier covers, keeping each route’s total mail within the capacity of that carrier’s bag. The goal is to keep the overall driving low: take each carrier’s route length, add them up, and the plan with the lowest total miles is best. The concrete stop-by-stop details appear below.
# total_stops_including_post_office=15
# post_office_stop_id=1
# carrier_mailbag_capacity=142
stop_id,map_x_coordinate,map_y_coordinate,mail_items_to_deliver
1,0,0,0
2,83,43,87
3,23,100,96
4,19,17,56
5,69,21,100
6,49,32,2
7,16,18,4
8,61,25,5
9,7,22,6
10,100,98,8
11,86,82,4
12,31,52,3
13,33,18,4
14,15,93,7
15,30,67,7
Also, when you send the planned routes back, please use this simple JSON shape so it's easy to read and parse:
{
""solution"": [[post_office_id, house_id, ... , post_office_id], [post_office_id, house_id, ... , post_office_id], ...]
}
This shows the general layout: ""solution"" is a list of routes, each inner list is the sequence of stops a single carrier will follow (starting and ending at the post office). It's just a sketch of the expected shape — not the actual answer.
Please make sure to use the exact identifiers from the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 0], [83, 43], [23, 100], [19, 17], [69, 21], [49, 32], [16, 18], [61, 25], [7, 22], [100, 98], [86, 82], [31, 52], [33, 18], [15, 93], [30, 67]], 'depot': 0, 'demands': [0, 87, 96, 56, 100, 2, 4, 5, 6, 8, 4, 3, 4, 7, 7], 'capacity': 142, 'num_vehicles': 3, 'total_distance': 941.9561407885084, 'objective': 941.9561407885084}","[[0, 9, 14, 5, 7, 6, 0], [0, 12, 4, 10, 13, 8, 0], [0, 3, 1, 11, 2, 0]]",941.9561407885084,"{'problem_type': 'CVRP', 'num_nodes': 15, 'nodes': [{'id': 1, 'x': 0, 'y': 0, 'demand': 0}, {'id': 2, 'x': 83, 'y': 43, 'demand': 87}, {'id': 3, 'x': 23, 'y': 100, 'demand': 96}, {'id': 4, 'x': 19, 'y': 17, 'demand': 56}, {'id': 5, 'x': 69, 'y': 21, 'demand': 100}, {'id': 6, 'x': 49, 'y': 32, 'demand': 2}, {'id': 7, 'x': 16, 'y': 18, 'demand': 4}, {'id': 8, 'x': 61, 'y': 25, 'demand': 5}, {'id': 9, 'x': 7, 'y': 22, 'demand': 6}, {'id': 10, 'x': 100, 'y': 98, 'demand': 8}, {'id': 11, 'x': 86, 'y': 82, 'demand': 4}, {'id': 12, 'x': 31, 'y': 52, 'demand': 3}, {'id': 13, 'x': 33, 'y': 18, 'demand': 4}, {'id': 14, 'x': 15, 'y': 93, 'demand': 7}, {'id': 15, 'x': 30, 'y': 67, 'demand': 7}], 'depot': 1, 'capacity': 142, 'num_vehicles': 3, 'total_distance': 941.9561407885084, 'objective': 941.9561407885084}","[[1, 10, 15, 6, 8, 7, 1], [1, 13, 5, 11, 14, 9, 1], [1, 4, 2, 12, 3, 1]]",2,csv,1
CVRP,CVRP,"A small school district wants to set up bus runs that begin and end at the district garage, pick up every child exactly once, and never put more kids on a bus than it can seat. The task is to figure out which students go on which bus and the order of stops for each run so nobody is missed or picked up more than once. The measure of a good plan is simple: the less the entire fleet has to drive, the better — add together the distances of all the bus routes to get that total, and try to reduce it. The concrete list of stops, student counts, and vehicle capacities appears below.
There are 14 total stops including the garage; the garage stop id is 0; each bus has a seating capacity of 745 students.
| stop_id | map_x_coordinate | map_y_coordinate | students_waiting |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 21 | 78 | 28 |
| 2 | 72 | 77 | 96 |
| 3 | 70 | 77 | 84 |
| 4 | 10 | 72 | 28 |
| 5 | 77 | 94 | 81 |
| 6 | 100 | 83 | 52 |
| 7 | 49 | 2 | 80 |
| 8 | 93 | 100 | 90 |
| 9 | 69 | 5 | 32 |
| 10 | 52 | 2 | 12 |
| 11 | 66 | 4 | 40 |
| 12 | 91 | 90 | 88 |
| 13 | 92 | 98 | 66 |
All routes must start and end at garage 0, visit every one of the 14 stops exactly once, and never carry more than 745 students on a run.
Also, when you reply, it'd be great if you follow a simple JSON layout so it's easy to read and check. Something like this:
{
""solution"": [[garage_id, stop_id, ... , garage_id], [garage_id, stop_id, ... , garage_id], ...]
}
This is just a sketch of the shape I expect: ""solution"" is a list of bus runs, each run is an ordered list of stop identifiers that starts and ends at the garage. Use the actual stop IDs from the instance for the garage and each stop — don't invent new names. The JSON above is only the shape, not the real plan.
Please use the exact identifiers given in the problem input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 0], [21, 78], [72, 77], [70, 77], [10, 72], [77, 94], [100, 83], [49, 2], [93, 100], [69, 5], [52, 2], [66, 4], [91, 90], [92, 98]], 'depot': 0, 'demands': [0, 28, 96, 84, 28, 81, 52, 80, 90, 32, 12, 40, 88, 66], 'capacity': 745, 'num_vehicles': 2, 'total_distance': 444.09838466296924, 'objective': 444.09838466296924}","[[0, 7, 0], [0, 10, 11, 9, 6, 12, 13, 8, 5, 2, 3, 1, 4, 0]]",444.09838466296924,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 0, 'x': 0, 'y': 0, 'demand': 0}, {'id': 1, 'x': 21, 'y': 78, 'demand': 28}, {'id': 2, 'x': 72, 'y': 77, 'demand': 96}, {'id': 3, 'x': 70, 'y': 77, 'demand': 84}, {'id': 4, 'x': 10, 'y': 72, 'demand': 28}, {'id': 5, 'x': 77, 'y': 94, 'demand': 81}, {'id': 6, 'x': 100, 'y': 83, 'demand': 52}, {'id': 7, 'x': 49, 'y': 2, 'demand': 80}, {'id': 8, 'x': 93, 'y': 100, 'demand': 90}, {'id': 9, 'x': 69, 'y': 5, 'demand': 32}, {'id': 10, 'x': 52, 'y': 2, 'demand': 12}, {'id': 11, 'x': 66, 'y': 4, 'demand': 40}, {'id': 12, 'x': 91, 'y': 90, 'demand': 88}, {'id': 13, 'x': 92, 'y': 98, 'demand': 66}], 'depot': 0, 'capacity': 745, 'num_vehicles': 2, 'total_distance': 444.09838466296924, 'objective': 444.09838466296924}","[[0, 7, 0], [0, 10, 11, 9, 6, 12, 13, 8, 5, 2, 3, 1, 4, 0]]",3,markdown_table,0
CVRP,CVRP,"Recently the kitchen had a full day of events and had to split up deliveries: the decision was how to group stops for each van so every event gets its drop exactly once, all routes begin and end at the kitchen, and loads stay within each vehicle’s limit. The clearer winner was the plan with the least total driving — just add up the distance of each round trip to see which plan wins. The concrete details follow below.
{
""total_locations_including_kitchen"": 14,
""nodes"": [
{
""location_id"": ""A"",
""location_x"": 32,
""location_y"": 51,
""order_quantity"": 0
},
{
""location_id"": ""B"",
""location_x"": 70,
""location_y"": 100,
""order_quantity"": 16
},
{
""location_id"": ""C"",
""location_x"": 0,
""location_y"": 69,
""order_quantity"": 20
},
{
""location_id"": ""D"",
""location_x"": 100,
""location_y"": 2,
""order_quantity"": 18
},
{
""location_id"": ""E"",
""location_x"": 22,
""location_y"": 60,
""order_quantity"": 23
},
{
""location_id"": ""F"",
""location_x"": 27,
""location_y"": 9,
""order_quantity"": 22
},
{
""location_id"": ""G"",
""location_x"": 78,
""location_y"": 18,
""order_quantity"": 17
},
{
""location_id"": ""H"",
""location_x"": 84,
""location_y"": 80,
""order_quantity"": 23
},
{
""location_id"": ""I"",
""location_x"": 81,
""location_y"": 91,
""order_quantity"": 5
},
{
""location_id"": ""J"",
""location_x"": 11,
""location_y"": 44,
""order_quantity"": 6
},
{
""location_id"": ""K"",
""location_x"": 3,
""location_y"": 64,
""order_quantity"": 8
},
{
""location_id"": ""L"",
""location_x"": 14,
""location_y"": 71,
""order_quantity"": 14
},
{
""location_id"": ""M"",
""location_x"": 92,
""location_y"": 0,
""order_quantity"": 6
},
{
""location_id"": ""N"",
""location_x"": 65,
""location_y"": 29,
""order_quantity"": 20
}
],
""kitchen_node_id"": ""A"",
""van_capacity"": 100
}
If you want to hand me the route plan, a nice compact way is this JSON shape — just a top-level ""solution"" with a list of round trips:
{
""solution"": [[kitchen_id, stop_id, ... , kitchen_id], [kitchen_id, stop_id, ... , kitchen_id], ...]
}
Think of it like a little form: each inner list is one van's round trip (start at the kitchen, visit the listed stops in order, then return to the kitchen), and the outer list is the whole set of vans/routes. This is just a sketch of the shape I expect, not the actual answer.
Please use the exact identifiers from the instance input — no renaming and no extra labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[32, 51], [70, 100], [0, 69], [100, 2], [22, 60], [27, 9], [78, 18], [84, 80], [81, 91], [11, 44], [3, 64], [14, 71], [92, 0], [65, 29]], 'depot': 0, 'demands': [0, 16, 20, 18, 23, 22, 17, 23, 5, 6, 8, 14, 6, 20], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 469.9724012674905, 'objective': 469.9724012674905}","[[0, 11, 1, 8, 7, 3, 12, 6, 0], [0, 13, 5, 9, 2, 10, 4, 0]]",469.9724012674905,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 32, 'y': 51, 'demand': 0}, {'id': 'B', 'x': 70, 'y': 100, 'demand': 16}, {'id': 'C', 'x': 0, 'y': 69, 'demand': 20}, {'id': 'D', 'x': 100, 'y': 2, 'demand': 18}, {'id': 'E', 'x': 22, 'y': 60, 'demand': 23}, {'id': 'F', 'x': 27, 'y': 9, 'demand': 22}, {'id': 'G', 'x': 78, 'y': 18, 'demand': 17}, {'id': 'H', 'x': 84, 'y': 80, 'demand': 23}, {'id': 'I', 'x': 81, 'y': 91, 'demand': 5}, {'id': 'J', 'x': 11, 'y': 44, 'demand': 6}, {'id': 'K', 'x': 3, 'y': 64, 'demand': 8}, {'id': 'L', 'x': 14, 'y': 71, 'demand': 14}, {'id': 'M', 'x': 92, 'y': 0, 'demand': 6}, {'id': 'N', 'x': 65, 'y': 29, 'demand': 20}], 'depot': 'A', 'capacity': 100, 'num_vehicles': 2, 'total_distance': 469.9724012674905, 'objective': 469.9724012674905}","[['A', 'L', 'B', 'I', 'H', 'D', 'M', 'G', 'A'], ['A', 'N', 'F', 'J', 'C', 'K', 'E', 'A']]",4,json,names
CVRP,CVRP,"There’s a routine to organize: nurses head out from the clinic, call on a list of patients, and then end the day back at the same clinic, with no patient getting more than one visit. Vehicles carry limited equipment, so each tour must fit within that load limit. The winning setup is the one that produces the fewest total miles driven (just add up the distance of every tour), and the concrete details — who’s where and how much they need, plus vehicle limits — appear below.
There are 15 locations including the clinic; nurses start and end every tour at clinic node A, and each vehicle can carry up to 40 units of equipment.
| location_node_id | x_coordinate | y_coordinate | equipment_demand |
|---|---|---|---|
| A | 8 | 31 | 0 |
| B | 61 | 52 | 30 |
| C | 69 | 88 | 16 |
| D | 11 | 83 | 23 |
| E | 69 | 14 | 11 |
| F | 69 | 33 | 15 |
| G | 0 | 98 | 7 |
| H | 44 | 95 | 14 |
| I | 86 | 50 | 6 |
| J | 86 | 0 | 19 |
| K | 28 | 100 | 11 |
| L | 31 | 45 | 12 |
| M | 100 | 100 | 6 |
| N | 50 | 19 | 15 |
| O | 14 | 29 | 5 |
Ensure each nurse returns to clinic A and that no route exceeds the vehicle equipment capacity of 40 across the 15 locations.
When you send the routes back, just use a little JSON sketch like this so it's easy to read and parse:
{
""solution"": [[""clinic_id"", ""patient_id"", ... , ""clinic_id""], [""clinic_id"", ""patient_id"", ... , ""clinic_id""], ...]
}
Each inner list is one nurse's round: start at the clinic, visit the listed patients in order, then finish back at the clinic. Think of it like filling out a simple route sheet — it's just the order of stops for each vehicle. The block above is only an example of the shape I need, not the actual routes.
Please use the exact identifiers from the instance input — don't rename them or make up new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'coordinates': [[8, 31], [61, 52], [69, 88], [11, 83], [69, 14], [69, 33], [0, 98], [44, 95], [86, 50], [86, 0], [28, 100], [31, 45], [100, 100], [50, 19], [14, 29]], 'depot': 0, 'demands': [0, 30, 16, 23, 11, 15, 7, 14, 6, 19, 11, 12, 6, 15, 5], 'capacity': 40, 'num_vehicles': 5, 'total_distance': 918.8684314798496, 'objective': 918.8684314798496}","[[0, 11, 4, 13, 0], [0, 3, 7, 0], [0, 1, 14, 0], [0, 6, 10, 12, 2, 0], [0, 5, 8, 9, 0]]",918.8684314798496,"{'problem_type': 'CVRP', 'num_nodes': 15, 'nodes': [{'id': 'A', 'x': 8, 'y': 31, 'demand': 0}, {'id': 'B', 'x': 61, 'y': 52, 'demand': 30}, {'id': 'C', 'x': 69, 'y': 88, 'demand': 16}, {'id': 'D', 'x': 11, 'y': 83, 'demand': 23}, {'id': 'E', 'x': 69, 'y': 14, 'demand': 11}, {'id': 'F', 'x': 69, 'y': 33, 'demand': 15}, {'id': 'G', 'x': 0, 'y': 98, 'demand': 7}, {'id': 'H', 'x': 44, 'y': 95, 'demand': 14}, {'id': 'I', 'x': 86, 'y': 50, 'demand': 6}, {'id': 'J', 'x': 86, 'y': 0, 'demand': 19}, {'id': 'K', 'x': 28, 'y': 100, 'demand': 11}, {'id': 'L', 'x': 31, 'y': 45, 'demand': 12}, {'id': 'M', 'x': 100, 'y': 100, 'demand': 6}, {'id': 'N', 'x': 50, 'y': 19, 'demand': 15}, {'id': 'O', 'x': 14, 'y': 29, 'demand': 5}], 'depot': 'A', 'capacity': 40, 'num_vehicles': 5, 'total_distance': 918.8684314798496, 'objective': 918.8684314798496}","[['A', 'L', 'E', 'N', 'A'], ['A', 'D', 'H', 'A'], ['A', 'B', 'O', 'A'], ['A', 'G', 'K', 'M', 'C', 'A'], ['A', 'F', 'I', 'J', 'A']]",5,markdown_table,names
CVRP,CVRP,"Someone from the shop is mapping out routes so the delivery vans can drop off all the orders — each address visited only once — then head back to base, making sure no van carries more bouquets than it’s supposed to. The decision is which stops to bundle on each van and in what sequence; the winning plan is the one with the smallest total driving distance, computed by totalling every van’s round-trip kilometres. The full list of addresses, demands and vehicle limits is shown below.
{
""total_locations_including_shop"": 14,
""nodes"": [
{
""address_node_id"": ""A"",
""x_coordinate_km"": 8,
""y_coordinate_km"": 31,
""bouquets_required"": 0
},
{
""address_node_id"": ""B"",
""x_coordinate_km"": 61,
""y_coordinate_km"": 52,
""bouquets_required"": 30
},
{
""address_node_id"": ""C"",
""x_coordinate_km"": 69,
""y_coordinate_km"": 88,
""bouquets_required"": 16
},
{
""address_node_id"": ""D"",
""x_coordinate_km"": 11,
""y_coordinate_km"": 83,
""bouquets_required"": 23
},
{
""address_node_id"": ""E"",
""x_coordinate_km"": 69,
""y_coordinate_km"": 14,
""bouquets_required"": 11
},
{
""address_node_id"": ""F"",
""x_coordinate_km"": 42,
""y_coordinate_km"": 33,
""bouquets_required"": 31
},
{
""address_node_id"": ""G"",
""x_coordinate_km"": 42,
""y_coordinate_km"": 71,
""bouquets_required"": 8
},
{
""address_node_id"": ""H"",
""x_coordinate_km"": 0,
""y_coordinate_km"": 98,
""bouquets_required"": 7
},
{
""address_node_id"": ""I"",
""x_coordinate_km"": 44,
""y_coordinate_km"": 95,
""bouquets_required"": 14
},
{
""address_node_id"": ""J"",
""x_coordinate_km"": 86,
""y_coordinate_km"": 50,
""bouquets_required"": 6
},
{
""address_node_id"": ""K"",
""x_coordinate_km"": 86,
""y_coordinate_km"": 0,
""bouquets_required"": 19
},
{
""address_node_id"": ""L"",
""x_coordinate_km"": 28,
""y_coordinate_km"": 100,
""bouquets_required"": 11
},
{
""address_node_id"": ""M"",
""x_coordinate_km"": 97,
""y_coordinate_km"": 86,
""bouquets_required"": 17
},
{
""address_node_id"": ""N"",
""x_coordinate_km"": 100,
""y_coordinate_km"": 100,
""bouquets_required"": 6
}
],
""shop_node_id"": ""A"",
""van_capacity_bouquets"": 160
}
You can just send back the routes in a little JSON shape like this — nothing fancy, just a quick sketch of the layout I expect:
{
""solution"": [[""shop_id"", ""address_id"", ""..."", ""shop_id""], [""shop_id"", ""address_id"", ""..."", ""shop_id""], ""...""]
}
Here ""solution"" is a list of van routes, each route itself is a list that starts and ends at the shop (the depot) and has the stops in the visiting order. Think of it like filling out a form: one inner list per van, each inner list showing the sequence of IDs the van will visit, returning to the shop at the end. This is only the expected shape — not the actual answer.
Please make sure every identifier you use matches the instance input exactly — do not rename any IDs or invent new ones. For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[8, 31], [61, 52], [69, 88], [11, 83], [69, 14], [42, 33], [42, 71], [0, 98], [44, 95], [86, 50], [86, 0], [28, 100], [97, 86], [100, 100]], 'depot': 0, 'demands': [0, 30, 16, 23, 11, 31, 8, 7, 14, 6, 19, 11, 17, 6], 'capacity': 160, 'num_vehicles': 2, 'total_distance': 502.3296493181866, 'objective': 502.3296493181866}","[[0, 4, 10, 9, 12, 13, 2, 8, 11, 7, 3, 0], [0, 6, 1, 5, 0]]",502.3296493181866,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 8, 'y': 31, 'demand': 0}, {'id': 'B', 'x': 61, 'y': 52, 'demand': 30}, {'id': 'C', 'x': 69, 'y': 88, 'demand': 16}, {'id': 'D', 'x': 11, 'y': 83, 'demand': 23}, {'id': 'E', 'x': 69, 'y': 14, 'demand': 11}, {'id': 'F', 'x': 42, 'y': 33, 'demand': 31}, {'id': 'G', 'x': 42, 'y': 71, 'demand': 8}, {'id': 'H', 'x': 0, 'y': 98, 'demand': 7}, {'id': 'I', 'x': 44, 'y': 95, 'demand': 14}, {'id': 'J', 'x': 86, 'y': 50, 'demand': 6}, {'id': 'K', 'x': 86, 'y': 0, 'demand': 19}, {'id': 'L', 'x': 28, 'y': 100, 'demand': 11}, {'id': 'M', 'x': 97, 'y': 86, 'demand': 17}, {'id': 'N', 'x': 100, 'y': 100, 'demand': 6}], 'depot': 'A', 'capacity': 160, 'num_vehicles': 2, 'total_distance': 502.3296493181866, 'objective': 502.3296493181866}","[['A', 'E', 'K', 'J', 'M', 'N', 'C', 'I', 'L', 'H', 'D', 'A'], ['A', 'G', 'B', 'F', 'A']]",6,json,names
CVRP,CVRP,"Recently the city wanted to tidy up its collection plan: every truck departs from the depot, empties a selection of pickup points, and returns at the end of the run. Planners must decide how to group stops into circuits so every pickup gets emptied once and no truck is overloaded. The simplest way to compare plans is to look at the fleet’s total miles — sum the distance of each truck’s route and pick the plan with the smallest total. The concrete route details are shown below.
# num_locations_including_depot=14
# depot_node_id=0
# vehicle_capacity=188
location_id,x_coordinate,y_coordinate,pickup_demand
0,100,100,0
1,0,38,75
2,1,54,31
3,9,84,25
4,2,37,100
5,66,37,19
6,4,53,47
7,88,57,74
8,80,5,47
9,81,0,36
10,9,18,95
11,7,34,65
12,19,99,17
13,0,51,52
You can just send the routes in a little JSON shape like this:
{
""solution"": [[""depot_id"", ""location_id"", ... , ""depot_id""], [""depot_id"", ""location_id"", ... , ""depot_id""], ...]
}
Each inner list is one truck’s circuit — start at the depot, list the pickup points in visit order, and come back to the depot at the end. Think of it like filling in a form: the outer array is the fleet, each inner array is a route.
This is just a sketch of the expected shape, not the actual answer. Please use the exact identifiers from the problem input — don’t rename them or invent new ones.
- for example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[100, 100], [0, 38], [1, 54], [9, 84], [2, 37], [66, 37], [4, 53], [88, 57], [80, 5], [81, 0], [9, 18], [7, 34], [19, 99], [0, 51]], 'depot': 0, 'demands': [0, 75, 31, 25, 100, 19, 47, 74, 47, 36, 95, 65, 17, 52], 'capacity': 188, 'num_vehicles': 4, 'total_distance': 947.3510471369788, 'objective': 947.3510471369788}","[[0, 12, 3, 2, 13, 6, 0], [0, 1, 4, 0], [0, 11, 10, 0], [0, 5, 8, 9, 7, 0]]",947.3510471369788,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 0, 'x': 100, 'y': 100, 'demand': 0}, {'id': 1, 'x': 0, 'y': 38, 'demand': 75}, {'id': 2, 'x': 1, 'y': 54, 'demand': 31}, {'id': 3, 'x': 9, 'y': 84, 'demand': 25}, {'id': 4, 'x': 2, 'y': 37, 'demand': 100}, {'id': 5, 'x': 66, 'y': 37, 'demand': 19}, {'id': 6, 'x': 4, 'y': 53, 'demand': 47}, {'id': 7, 'x': 88, 'y': 57, 'demand': 74}, {'id': 8, 'x': 80, 'y': 5, 'demand': 47}, {'id': 9, 'x': 81, 'y': 0, 'demand': 36}, {'id': 10, 'x': 9, 'y': 18, 'demand': 95}, {'id': 11, 'x': 7, 'y': 34, 'demand': 65}, {'id': 12, 'x': 19, 'y': 99, 'demand': 17}, {'id': 13, 'x': 0, 'y': 51, 'demand': 52}], 'depot': 0, 'capacity': 188, 'num_vehicles': 4, 'total_distance': 947.3510471369788, 'objective': 947.3510471369788}","[[0, 12, 3, 2, 13, 6, 0], [0, 1, 4, 0], [0, 11, 10, 0], [0, 5, 8, 9, 7, 0]]",7,csv,0
CVRP,CVRP,"On a busy morning the dispatch team must assign each truck a set of retailers to visit, with every truck leaving from and coming back to the warehouse and carrying only up to its allowed load. The decision is which shops go on which truck runs so no store is skipped or double-served and no vehicle is overloaded. The preferred plan is the one with the lowest total distance traveled by the whole fleet — you figure that by summing the distance of each round-trip — and the specific instance details are listed below.
There are 11 locations in total; the warehouse is node A; each truck may carry up to 100 units.
Location A is at (58, 61) and requires 0 units.
Location B is at (87, 16) and requires 21 units.
Location C is at (100, 100) and requires 31 units.
Location D is at (0, 98) and requires 13 units.
Location E is at (66, 0) and requires 28 units.
Location F is at (60, 75) and requires 18 units.
Location G is at (25, 91) and requires 28 units.
Location H is at (96, 5) and requires 14 units.
Location I is at (11, 2) and requires 11 units.
Location J is at (79, 66) and requires 27 units.
Location K is at (6, 57) and requires 5 units.
Routes must start and end at node A, serve each location exactly once, and never exceed the 100-unit truck limit.
Oh, and when you send back the planned runs, please follow this simple JSON shape so I can read it automatically:
{
""solution"": [[warehouse_id, retailer_id, ... , warehouse_id], [warehouse_id, retailer_id, ... , warehouse_id], ...]
}
Think of it like a form: ""solution"" holds a list of truck routes, each route is the round-trip sequence starting and ending at the warehouse (warehouse_id) and listing the shops (retailer_id) in the order they're visited. The ellipses just mean you can have as many stops as needed. This is only a sketch of the expected shape — not the actual answer.
Please be sure to use the exact identifiers from the instance input — don't rename them or add new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[58, 61], [87, 16], [100, 100], [0, 98], [66, 0], [60, 75], [25, 91], [96, 5], [11, 2], [79, 66], [6, 57]], 'depot': 0, 'demands': [0, 21, 31, 13, 28, 18, 28, 14, 11, 27, 5], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 511.3337061734518, 'objective': 511.3337061734518}","[[0, 1, 7, 4, 8, 10, 5, 0], [0, 3, 6, 2, 9, 0]]",511.3337061734518,"{'problem_type': 'CVRP', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 58, 'y': 61, 'demand': 0}, {'id': 'B', 'x': 87, 'y': 16, 'demand': 21}, {'id': 'C', 'x': 100, 'y': 100, 'demand': 31}, {'id': 'D', 'x': 0, 'y': 98, 'demand': 13}, {'id': 'E', 'x': 66, 'y': 0, 'demand': 28}, {'id': 'F', 'x': 60, 'y': 75, 'demand': 18}, {'id': 'G', 'x': 25, 'y': 91, 'demand': 28}, {'id': 'H', 'x': 96, 'y': 5, 'demand': 14}, {'id': 'I', 'x': 11, 'y': 2, 'demand': 11}, {'id': 'J', 'x': 79, 'y': 66, 'demand': 27}, {'id': 'K', 'x': 6, 'y': 57, 'demand': 5}], 'depot': 'A', 'capacity': 100, 'num_vehicles': 2, 'total_distance': 511.3337061734518, 'objective': 511.3337061734518}","[['A', 'B', 'H', 'E', 'I', 'K', 'F', 'A'], ['A', 'D', 'G', 'C', 'J', 'A']]",8,nl,names
CVRP,CVRP,"I run the bookmobile for a small branch and need to plan the day so each neighborhood stop gets a visit exactly once. The job is to pick which vans go to which stops, making sure no van takes more books than its shelves can hold, and every route starts and ends back at the branch. The better plan is simply the one that keeps the overall driving down — add up the distance of each van’s loop and aim for the smallest total. The exact stops, distances, and vehicle shelving limits are shown below.
I have 14 locations including the branch 1, and each van can carry up to 100 books.
I have stop 1 at (48, 91) requiring 0 books.
I have stop 2 at (100, 9) requiring 18 books.
I have stop 3 at (87, 14) requiring 10 books.
I have stop 4 at (59, 44) requiring 13 books.
I have stop 5 at (0, 44) requiring 3 books.
I have stop 6 at (0, 53) requiring 11 books.
I have stop 7 at (66, 35) requiring 14 books.
I have stop 8 at (76, 95) requiring 12 books.
I have stop 9 at (76, 100) requiring 6 books.
I have stop 10 at (89, 47) requiring 15 books.
I have stop 11 at (41, 0) requiring 5 books.
I have stop 12 at (99, 26) requiring 19 books.
I have stop 13 at (60, 51) requiring 26 books.
I have stop 14 at (88, 42) requiring 8 books.
I'll use these details to assign vans and minimize total driving while respecting the van shelving capacity of 100.
Also, when you send me the plan, keep it in this simple JSON layout so it's easy to read and plug in:
{
""solution"": [[branch_id, stop_id, ... , branch_id], [branch_id, stop_id, ... , branch_id], ...]
}
Here ""solution"" is a list of routes. Each route is a list of place identifiers starting and ending at the branch (the first and last entry in each inner list). Think of each inner list as one van's loop: branch → stop → stop → … → branch. This snippet is just a sketch of the shape I expect — not the actual plan.
Please make sure you use the exact identifiers from the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[48, 91], [100, 9], [87, 14], [59, 44], [0, 44], [0, 53], [66, 35], [76, 95], [76, 100], [89, 47], [41, 0], [99, 26], [60, 51], [88, 42]], 'depot': 0, 'demands': [0, 18, 10, 13, 3, 11, 14, 12, 6, 15, 5, 19, 26, 8], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 449.5330099476179, 'objective': 449.5330099476179}","[[0, 12, 3, 6, 7, 8, 0], [0, 9, 13, 11, 1, 2, 10, 4, 5, 0]]",449.5330099476179,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 1, 'x': 48, 'y': 91, 'demand': 0}, {'id': 2, 'x': 100, 'y': 9, 'demand': 18}, {'id': 3, 'x': 87, 'y': 14, 'demand': 10}, {'id': 4, 'x': 59, 'y': 44, 'demand': 13}, {'id': 5, 'x': 0, 'y': 44, 'demand': 3}, {'id': 6, 'x': 0, 'y': 53, 'demand': 11}, {'id': 7, 'x': 66, 'y': 35, 'demand': 14}, {'id': 8, 'x': 76, 'y': 95, 'demand': 12}, {'id': 9, 'x': 76, 'y': 100, 'demand': 6}, {'id': 10, 'x': 89, 'y': 47, 'demand': 15}, {'id': 11, 'x': 41, 'y': 0, 'demand': 5}, {'id': 12, 'x': 99, 'y': 26, 'demand': 19}, {'id': 13, 'x': 60, 'y': 51, 'demand': 26}, {'id': 14, 'x': 88, 'y': 42, 'demand': 8}], 'depot': 1, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 449.5330099476179, 'objective': 449.5330099476179}","[[1, 13, 4, 7, 8, 9, 1], [1, 10, 14, 12, 2, 3, 11, 5, 6, 1]]",9,nl,1
CVRP,CVRP,"We need to lay out pickup runs from the lab for several couriers: each run starts at the lab, visits some clinics, then returns to the lab, and every clinic must be visited once and only once. Each courier’s cooler has a maximum load, so the number of specimens per run has to fit, and the better plan is the one where the sum of all route distances is lowest — simply total the miles of every courier’s circuit to compare plans. The specific clinics, sample counts, cooler capacities, and route distances are listed below.
{
""total_locations_including_lab"": 11,
""nodes"": [
{
""location_id"": 0,
""x_coordinate_miles"": 63,
""y_coordinate_miles"": 100,
""specimens_to_pickup"": 0
},
{
""location_id"": 1,
""x_coordinate_miles"": 55,
""y_coordinate_miles"": 17,
""specimens_to_pickup"": 12
},
{
""location_id"": 2,
""x_coordinate_miles"": 82,
""y_coordinate_miles"": 61,
""specimens_to_pickup"": 1
},
{
""location_id"": 3,
""x_coordinate_miles"": 79,
""y_coordinate_miles"": 30,
""specimens_to_pickup"": 20
},
{
""location_id"": 4,
""x_coordinate_miles"": 5,
""y_coordinate_miles"": 30,
""specimens_to_pickup"": 14
},
{
""location_id"": 5,
""x_coordinate_miles"": 100,
""y_coordinate_miles"": 28,
""specimens_to_pickup"": 8
},
{
""location_id"": 6,
""x_coordinate_miles"": 0,
""y_coordinate_miles"": 63,
""specimens_to_pickup"": 12
},
{
""location_id"": 7,
""x_coordinate_miles"": 66,
""y_coordinate_miles"": 2,
""specimens_to_pickup"": 20
},
{
""location_id"": 8,
""x_coordinate_miles"": 92,
""y_coordinate_miles"": 0,
""specimens_to_pickup"": 15
},
{
""location_id"": 9,
""x_coordinate_miles"": 58,
""y_coordinate_miles"": 80,
""specimens_to_pickup"": 9
},
{
""location_id"": 10,
""x_coordinate_miles"": 5,
""y_coordinate_miles"": 7,
""specimens_to_pickup"": 6
}
],
""lab_node_id"": 0,
""cooler_capacity_specimens"": 100
}
Also, when you send back the plan, please stick to this simple JSON layout so it's easy for the system to pick up:
{
""solution"": [[lab_id, clinic_id, ... , lab_id], [lab_id, clinic_id, ... , lab_id], ...]
}
Pretty straightforward: ""solution"" is a list of runs, each inner list is one courier's circuit that starts and ends at the lab (lab_id), with the clinic ids visited in between — the ... just means you can have more clinic ids in that spot. This is just the shape I expect, not the actual answer.
One more thing: use the exact identifiers from the instance input — don't rename them or invent new ones. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”. Use those exact labels when you give the real routes.","{'coordinates': [[63, 100], [55, 17], [82, 61], [79, 30], [5, 30], [100, 28], [0, 63], [66, 2], [92, 0], [58, 80], [5, 7]], 'depot': 0, 'demands': [0, 12, 1, 20, 14, 8, 12, 20, 15, 9, 6], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 481.85049996795834, 'objective': 481.85049996795834}","[[0, 9, 3, 0], [0, 6, 4, 10, 1, 7, 8, 5, 2, 0]]",481.85049996795834,"{'problem_type': 'CVRP', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 63, 'y': 100, 'demand': 0}, {'id': 1, 'x': 55, 'y': 17, 'demand': 12}, {'id': 2, 'x': 82, 'y': 61, 'demand': 1}, {'id': 3, 'x': 79, 'y': 30, 'demand': 20}, {'id': 4, 'x': 5, 'y': 30, 'demand': 14}, {'id': 5, 'x': 100, 'y': 28, 'demand': 8}, {'id': 6, 'x': 0, 'y': 63, 'demand': 12}, {'id': 7, 'x': 66, 'y': 2, 'demand': 20}, {'id': 8, 'x': 92, 'y': 0, 'demand': 15}, {'id': 9, 'x': 58, 'y': 80, 'demand': 9}, {'id': 10, 'x': 5, 'y': 7, 'demand': 6}], 'depot': 0, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 481.85049996795834, 'objective': 481.85049996795834}","[[0, 9, 3, 0], [0, 6, 4, 10, 1, 7, 8, 5, 2, 0]]",10,json,0
CVRP,CVRP,"We’ve got a press, a stack of bundles, and a bunch of newsstands scattered around town; the challenge is figuring the runs for each carrier so each stand gets a single bundle and every runner comes back to the press. Every round has to respect what a carrier’s bag can hold, and nothing can be handed out twice or left out. The best way to judge two different sets of rounds is by how short their combined travel is — add up the distance of every round and the smaller total wins. The specific addresses, demands, and capacities are shown below.
There are 15 locations in total, the press is node A, and each carrier's bag holds up to 200 bundles.
Stand A is at (42, 56) and needs 0 bundles.
Stand B is at (47, 81) and needs 30 bundles.
Stand C is at (21, 94) and needs 40 bundles.
Stand D is at (32, 59) and needs 20 bundles.
Stand E is at (5, 38) and needs 10 bundles.
Stand F is at (0, 44) and needs 30 bundles.
Stand G is at (34, 31) and needs 10 bundles.
Stand H is at (42, 0) and needs 30 bundles.
Stand I is at (47, 38) and needs 10 bundles.
Stand J is at (100, 38) and needs 20 bundles.
Stand K is at (76, 62) and needs 10 bundles.
Stand L is at (68, 69) and needs 30 bundles.
Stand M is at (68, 100) and needs 40 bundles.
Stand N is at (63, 100) and needs 30 bundles.
Stand O is at (58, 94) and needs 10 bundles.
Routes must start and end at the press, respect the 200 bag limit, and minimize combined travel.
Oh — and when you hand me the routes back, please use this easy JSON shape so I can parse the runs without guessing:
{
""solution"": [[press_id, stand_id, ... , press_id], [press_id, stand_id, ... , press_id], ...]
}
Each inner list is one carrier’s run: it starts at the press (press_id), visits the stands in the order listed (stand_id placeholders), and returns to the press. The outer list collects all the runs. This is just a sketch of the shape I expect, not the actual answer.
Please be sure to use the exact identifiers from the instance input — don’t rename them or add new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[42, 56], [47, 81], [21, 94], [32, 59], [5, 38], [0, 44], [34, 31], [42, 0], [47, 38], [100, 38], [76, 62], [68, 69], [68, 100], [63, 100], [58, 94]], 'depot': 0, 'demands': [0, 30, 40, 20, 10, 30, 10, 30, 10, 20, 10, 30, 40, 30, 10], 'capacity': 200, 'num_vehicles': 2, 'total_distance': 419.30403537894387, 'objective': 419.30403537894387}","[[0, 9, 10, 11, 12, 13, 14, 1, 0], [0, 8, 6, 7, 4, 5, 2, 3, 0]]",419.30403537894387,"{'problem_type': 'CVRP', 'num_nodes': 15, 'nodes': [{'id': 'A', 'x': 42, 'y': 56, 'demand': 0}, {'id': 'B', 'x': 47, 'y': 81, 'demand': 30}, {'id': 'C', 'x': 21, 'y': 94, 'demand': 40}, {'id': 'D', 'x': 32, 'y': 59, 'demand': 20}, {'id': 'E', 'x': 5, 'y': 38, 'demand': 10}, {'id': 'F', 'x': 0, 'y': 44, 'demand': 30}, {'id': 'G', 'x': 34, 'y': 31, 'demand': 10}, {'id': 'H', 'x': 42, 'y': 0, 'demand': 30}, {'id': 'I', 'x': 47, 'y': 38, 'demand': 10}, {'id': 'J', 'x': 100, 'y': 38, 'demand': 20}, {'id': 'K', 'x': 76, 'y': 62, 'demand': 10}, {'id': 'L', 'x': 68, 'y': 69, 'demand': 30}, {'id': 'M', 'x': 68, 'y': 100, 'demand': 40}, {'id': 'N', 'x': 63, 'y': 100, 'demand': 30}, {'id': 'O', 'x': 58, 'y': 94, 'demand': 10}], 'depot': 'A', 'capacity': 200, 'num_vehicles': 2, 'total_distance': 419.30403537894387, 'objective': 419.30403537894387}","[['A', 'J', 'K', 'L', 'M', 'N', 'O', 'B', 'A'], ['A', 'I', 'G', 'H', 'E', 'F', 'C', 'D', 'A']]",11,nl,names
CVRP,CVRP,"At the warehouse the crew lays out routes so every truck leaves, performs one delivery at each assigned house, and comes back to base. The decision makers need to decide which addresses go on which truck and in what sequence so nobody gets skipped or double-served and vehicle load limits aren’t exceeded. The better routing is simply the one with the lowest total distance — add up the distance for every truck’s round trip and the smallest total wins. The concrete details for the loads and addresses are shown below.
There are 14 locations including the warehouse 0, and each truck may carry up to 100 units.
Address 0 is at (83, 78) and requires 0 units of load.
Address 1 is at (11, 5) and requires 19 units of load.
Address 2 is at (58, 29) and requires 12 units of load.
Address 3 is at (0, 39) and requires 16 units of load.
Address 4 is at (1, 84) and requires 8 units of load.
Address 5 is at (93, 0) and requires 19 units of load.
Address 6 is at (100, 13) and requires 12 units of load.
Address 7 is at (42, 7) and requires 8 units of load.
Address 8 is at (61, 63) and requires 24 units of load.
Address 9 is at (7, 100) and requires 24 units of load.
Address 10 is at (81, 56) and requires 2 units of load.
Address 11 is at (19, 72) and requires 2 units of load.
Address 12 is at (86, 61) and requires 14 units of load.
Address 13 is at (100, 3) and requires 9 units of load.
Assign each address to truck routes that start and end at 0, respect the 100 limit, and cover all 14 locations without duplication.
Oh, and when you hand in the routes, please follow this simple JSON layout so it's easy to read by the system:
{
""solution"": [[""warehouse_id"", ""location_id"", ... , ""warehouse_id""], [""warehouse_id"", ""location_id"", ... , ""warehouse_id""], ...]
}
This is just a sketch of the shape I expect: ""solution"" is a list of the trucks' round-trip routes, each route is a list of stop IDs that starts and ends at the depot (here labeled as ""warehouse_id"" in the example), and each inner list shows the sequence of addresses visited on that truck's trip. It's informal — think of it as filling out a short form that says which stops go on which truck and in what order.
Please be sure to use the exact identifiers from the instance input — don't rename them and don't invent new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[83, 78], [11, 5], [58, 29], [0, 39], [1, 84], [93, 0], [100, 13], [42, 7], [61, 63], [7, 100], [81, 56], [19, 72], [86, 61], [100, 3]], 'depot': 0, 'demands': [0, 19, 12, 16, 8, 19, 12, 8, 24, 24, 2, 2, 14, 9], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 490.5710558585651, 'objective': 490.5710558585651}","[[0, 11, 9, 4, 3, 1, 7, 2, 10, 0], [0, 12, 6, 13, 5, 8, 0]]",490.5710558585651,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 0, 'x': 83, 'y': 78, 'demand': 0}, {'id': 1, 'x': 11, 'y': 5, 'demand': 19}, {'id': 2, 'x': 58, 'y': 29, 'demand': 12}, {'id': 3, 'x': 0, 'y': 39, 'demand': 16}, {'id': 4, 'x': 1, 'y': 84, 'demand': 8}, {'id': 5, 'x': 93, 'y': 0, 'demand': 19}, {'id': 6, 'x': 100, 'y': 13, 'demand': 12}, {'id': 7, 'x': 42, 'y': 7, 'demand': 8}, {'id': 8, 'x': 61, 'y': 63, 'demand': 24}, {'id': 9, 'x': 7, 'y': 100, 'demand': 24}, {'id': 10, 'x': 81, 'y': 56, 'demand': 2}, {'id': 11, 'x': 19, 'y': 72, 'demand': 2}, {'id': 12, 'x': 86, 'y': 61, 'demand': 14}, {'id': 13, 'x': 100, 'y': 3, 'demand': 9}], 'depot': 0, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 490.5710558585651, 'objective': 490.5710558585651}","[[0, 11, 9, 4, 3, 1, 7, 2, 10, 0], [0, 12, 6, 13, 5, 8, 0]]",12,nl,0
CVRP,CVRP,"Many stores depend on a single pet supply hub, so the practical job is to split them into truck routes and choose the visit order so each shop is visited exactly once. Every trip must begin at the hub and return there, and no truck can carry more than its allowed load. The winner among possible plans is the one with the smallest combined mileage for all trucks — total distance equals the sum of each route’s length — and the detailed store and vehicle info is provided below.
{
""total_locations_including_hub"": 15,
""nodes"": [
{
""location_id"": 0,
""coord_x"": 47,
""coord_y"": 40,
""store_demand_units"": 0
},
{
""location_id"": 1,
""coord_x"": 64,
""coord_y"": 100,
""store_demand_units"": 1100
},
{
""location_id"": 2,
""coord_x"": 86,
""coord_y"": 96,
""store_demand_units"": 700
},
{
""location_id"": 3,
""coord_x"": 0,
""coord_y"": 85,
""store_demand_units"": 1400
},
{
""location_id"": 4,
""coord_x"": 97,
""coord_y"": 79,
""store_demand_units"": 2100
},
{
""location_id"": 5,
""coord_x"": 50,
""coord_y"": 78,
""store_demand_units"": 400
},
{
""location_id"": 6,
""coord_x"": 39,
""coord_y"": 70,
""store_demand_units"": 100
},
{
""location_id"": 7,
""coord_x"": 56,
""coord_y"": 61,
""store_demand_units"": 600
},
{
""location_id"": 8,
""coord_x"": 78,
""coord_y"": 43,
""store_demand_units"": 1300
},
{
""location_id"": 9,
""coord_x"": 50,
""coord_y"": 32,
""store_demand_units"": 300
},
{
""location_id"": 10,
""coord_x"": 36,
""coord_y"": 29,
""store_demand_units"": 2100
},
{
""location_id"": 11,
""coord_x"": 53,
""coord_y"": 13,
""store_demand_units"": 1000
},
{
""location_id"": 12,
""coord_x"": 100,
""coord_y"": 13,
""store_demand_units"": 900
},
{
""location_id"": 13,
""coord_x"": 3,
""coord_y"": 9,
""store_demand_units"": 2500
},
{
""location_id"": 14,
""coord_x"": 31,
""coord_y"": 0,
""store_demand_units"": 700
}
],
""hub_node_id"": 0,
""truck_capacity_units"": 6000
}
Also, when you send the plan back, just follow this simple JSON layout so I can read the routes programmatically:
{
""solution"": [[hub_id, store_id, ... , hub_id], [hub_id, store_id, ... , hub_id], ...]
}
This means ""solution"" is a list of truck trips. Each inner list is one trip: it starts at the hub, lists the stores in the order they’ll be visited, and ends back at the hub. Think of the JSON above as just the shape I want — a sketch, not the actual routing.
Please make sure to use the exact identifiers from the instance input — don’t rename anything and don’t invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[47, 40], [64, 100], [86, 96], [0, 85], [97, 79], [50, 78], [39, 70], [56, 61], [78, 43], [50, 32], [36, 29], [53, 13], [100, 13], [3, 9], [31, 0]], 'depot': 0, 'demands': [0, 1100, 700, 1400, 2100, 400, 100, 600, 1300, 300, 2100, 1000, 900, 2500, 700], 'capacity': 6000, 'num_vehicles': 3, 'total_distance': 542.4434420105493, 'objective': 542.4434420105493}","[[0, 9, 11, 12, 8, 7, 0], [0, 14, 13, 10, 0], [0, 3, 6, 5, 1, 2, 4, 0]]",542.4434420105493,"{'problem_type': 'CVRP', 'num_nodes': 15, 'nodes': [{'id': 0, 'x': 47, 'y': 40, 'demand': 0}, {'id': 1, 'x': 64, 'y': 100, 'demand': 1100}, {'id': 2, 'x': 86, 'y': 96, 'demand': 700}, {'id': 3, 'x': 0, 'y': 85, 'demand': 1400}, {'id': 4, 'x': 97, 'y': 79, 'demand': 2100}, {'id': 5, 'x': 50, 'y': 78, 'demand': 400}, {'id': 6, 'x': 39, 'y': 70, 'demand': 100}, {'id': 7, 'x': 56, 'y': 61, 'demand': 600}, {'id': 8, 'x': 78, 'y': 43, 'demand': 1300}, {'id': 9, 'x': 50, 'y': 32, 'demand': 300}, {'id': 10, 'x': 36, 'y': 29, 'demand': 2100}, {'id': 11, 'x': 53, 'y': 13, 'demand': 1000}, {'id': 12, 'x': 100, 'y': 13, 'demand': 900}, {'id': 13, 'x': 3, 'y': 9, 'demand': 2500}, {'id': 14, 'x': 31, 'y': 0, 'demand': 700}], 'depot': 0, 'capacity': 6000, 'num_vehicles': 3, 'total_distance': 542.4434420105493, 'objective': 542.4434420105493}","[[0, 9, 11, 12, 8, 7, 0], [0, 14, 13, 10, 0], [0, 3, 6, 5, 1, 2, 4, 0]]",13,json,0
CVRP,CVRP,"I’m picturing the maintenance yard dispatching trucks each morning to drop off tool kits to work crews around town. The task is to pick which crews each truck will visit so that every crew gets their delivery exactly once, every truck leaves from and returns to the yard, and no truck carries more weight than it can handle. The “best” way here is the one that keeps the fleet’s total miles driven as small as possible — you measure that by adding up the round-trip distance for every truck. The concrete details for the route plan and loads are shown below.
{
""total_locations_incl_yard"": 11,
""nodes"": [
{
""location_id"": 1,
""location_x"": 22,
""location_y"": 29,
""tool_kit_weight"": 0
},
{
""location_id"": 2,
""location_x"": 99,
""location_y"": 54,
""tool_kit_weight"": 15
},
{
""location_id"": 3,
""location_x"": 100,
""location_y"": 54,
""tool_kit_weight"": 5
},
{
""location_id"": 4,
""location_x"": 25,
""location_y"": 30,
""tool_kit_weight"": 165
},
{
""location_id"": 5,
""location_x"": 0,
""location_y"": 100,
""tool_kit_weight"": 65
},
{
""location_id"": 6,
""location_x"": 78,
""location_y"": 17,
""tool_kit_weight"": 52
},
{
""location_id"": 7,
""location_x"": 79,
""location_y"": 16,
""tool_kit_weight"": 1300
},
{
""location_id"": 8,
""location_x"": 82,
""location_y"": 42,
""tool_kit_weight"": 84
},
{
""location_id"": 9,
""location_x"": 46,
""location_y"": 33,
""tool_kit_weight"": 54
},
{
""location_id"": 10,
""location_x"": 47,
""location_y"": 32,
""tool_kit_weight"": 19
},
{
""location_id"": 11,
""location_x"": 49,
""location_y"": 0,
""tool_kit_weight"": 44
}
],
""yard_node_id"": 1,
""truck_capacity_weight"": 2010
}
Also, to keep things simple when you send the routes back, use this little JSON shape for the plan:
{
""solution"": [[yard_id, crew_id, ... , yard_id], [yard_id, crew_id, ... , yard_id], ...]
}
""solution"" is a list of routes. Each inner list is one truck’s round trip: it starts at the yard (yard_id), lists the crews to visit (crew_id) in the order they’ll be visited, and comes back to the yard. The ""..."" just means any number of stops can go there. This is just a sketch of the shape I expect — not the filled-in answer.
Please make sure you use the exact identifiers from the instance input — don’t rename things or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[22, 29], [99, 54], [100, 54], [25, 30], [0, 100], [78, 17], [79, 16], [82, 42], [46, 33], [47, 32], [49, 0]], 'depot': 0, 'demands': [0, 15, 5, 165, 65, 52, 1300, 84, 54, 19, 44], 'capacity': 2010, 'num_vehicles': 1, 'total_distance': 324.7960241364316, 'objective': 324.7960241364316}","[[0, 4, 2, 1, 7, 5, 6, 10, 9, 8, 3, 0]]",324.7960241364316,"{'problem_type': 'CVRP', 'num_nodes': 11, 'nodes': [{'id': 1, 'x': 22, 'y': 29, 'demand': 0}, {'id': 2, 'x': 99, 'y': 54, 'demand': 15}, {'id': 3, 'x': 100, 'y': 54, 'demand': 5}, {'id': 4, 'x': 25, 'y': 30, 'demand': 165}, {'id': 5, 'x': 0, 'y': 100, 'demand': 65}, {'id': 6, 'x': 78, 'y': 17, 'demand': 52}, {'id': 7, 'x': 79, 'y': 16, 'demand': 1300}, {'id': 8, 'x': 82, 'y': 42, 'demand': 84}, {'id': 9, 'x': 46, 'y': 33, 'demand': 54}, {'id': 10, 'x': 47, 'y': 32, 'demand': 19}, {'id': 11, 'x': 49, 'y': 0, 'demand': 44}], 'depot': 1, 'capacity': 2010, 'num_vehicles': 1, 'total_distance': 324.7960241364316, 'objective': 324.7960241364316}","[[1, 5, 3, 2, 8, 6, 7, 11, 10, 9, 4, 1]]",14,json,1
CVRP,CVRP,"Out at the yard, the vans get loaded, each with a limit on how many parts they can carry, and they’ll each head out and later return to the same service center to cover a list of repair calls. The planning question is which calls each van should take and in what order so every single call is handled once and no van leaves overloaded. The simple aim is to cut down the fleet’s total driving — the total is just the sum of the distances of every van’s circuit, and the smaller that sum, the better the plan. The concrete stops, part requirements, and vehicle limits are shown below.
Here are the instance details: 13 stops including the service center, service center id 1, each van has a limit of 794 parts.
Stop 1 at (51, 54) requires 0 parts.
Stop 2 at (7, 41) requires 89 parts.
Stop 3 at (0, 20) requires 7 parts.
Stop 4 at (24, 56) requires 16 parts.
Stop 5 at (14, 59) requires 51 parts.
Stop 6 at (67, 100) requires 39 parts.
Stop 7 at (53, 68) requires 4 parts.
Stop 8 at (62, 67) requires 81 parts.
Stop 9 at (79, 89) requires 21 parts.
Stop 10 at (10, 51) requires 43 parts.
Stop 11 at (44, 51) requires 59 parts.
Stop 12 at (13, 90) requires 52 parts.
Stop 13 at (100, 0) requires 26 parts.
Make routes so every stop is visited once, no van carries more than 794 parts, and the fleet’s total driving is kept as small as possible.
Also, when you hand the plan back, keep it in a tiny, predictable JSON shape so I can read it easily. Something like this:
{
""solution"": [[depot_id, location_id, ... , depot_id], [depot_id, location_id, ... , depot_id], ...]
}
Here ""solution"" is a list of van circuits. Each inner list is the sequence of stops for one van, starting and ending at the depot (so the first and last entry in each route are the depot_id). The placeholders depot_id and location_id stand for the identifiers used in the instance — think of them like the names on the schedule rather than actual addresses. This is just the skeleton of the format I need, not the real plan.
Please make sure to use the exact identifiers from the instance input — do not rename them or invent new labels. For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[51, 54], [7, 41], [0, 20], [24, 56], [14, 59], [67, 100], [53, 68], [62, 67], [79, 89], [10, 51], [44, 51], [13, 90], [100, 0]], 'depot': 0, 'demands': [0, 89, 7, 16, 51, 39, 4, 81, 21, 43, 59, 52, 26], 'capacity': 794, 'num_vehicles': 1, 'total_distance': 395.23245494899385, 'objective': 395.23245494899385}","[[0, 6, 7, 8, 5, 11, 3, 4, 9, 1, 2, 12, 10, 0]]",395.23245494899385,"{'problem_type': 'CVRP', 'num_nodes': 13, 'nodes': [{'id': 1, 'x': 51, 'y': 54, 'demand': 0}, {'id': 2, 'x': 7, 'y': 41, 'demand': 89}, {'id': 3, 'x': 0, 'y': 20, 'demand': 7}, {'id': 4, 'x': 24, 'y': 56, 'demand': 16}, {'id': 5, 'x': 14, 'y': 59, 'demand': 51}, {'id': 6, 'x': 67, 'y': 100, 'demand': 39}, {'id': 7, 'x': 53, 'y': 68, 'demand': 4}, {'id': 8, 'x': 62, 'y': 67, 'demand': 81}, {'id': 9, 'x': 79, 'y': 89, 'demand': 21}, {'id': 10, 'x': 10, 'y': 51, 'demand': 43}, {'id': 11, 'x': 44, 'y': 51, 'demand': 59}, {'id': 12, 'x': 13, 'y': 90, 'demand': 52}, {'id': 13, 'x': 100, 'y': 0, 'demand': 26}], 'depot': 1, 'capacity': 794, 'num_vehicles': 1, 'total_distance': 395.23245494899385, 'objective': 395.23245494899385}","[[1, 7, 8, 9, 6, 12, 4, 5, 10, 2, 3, 13, 11, 1]]",15,nl,1
CVRP,CVRP,"Recently the freezer team had to plan a set of runs to refill trucks across the city: each restock vehicle departs the cold storage, visits a selection of ice cream trucks once apiece, and then comes back. The constraint is that no vehicle can carry more ice cream than its freezer holds, and success is measured by how little total distance all the vans cover — the total is the sum of every route’s distance. The full list of truck demands and vehicle capacities is listed below.
{
""total_locations_including_depot"": 12,
""nodes"": [
{
""location_id"": 0,
""x_coordinate"": 65,
""y_coordinate"": 0,
""ice_cream_demand_units"": 0
},
{
""location_id"": 1,
""x_coordinate"": 93,
""y_coordinate"": 55,
""ice_cream_demand_units"": 24
},
{
""location_id"": 2,
""x_coordinate"": 14,
""y_coordinate"": 59,
""ice_cream_demand_units"": 9
},
{
""location_id"": 3,
""x_coordinate"": 74,
""y_coordinate"": 7,
""ice_cream_demand_units"": 17
},
{
""location_id"": 4,
""x_coordinate"": 95,
""y_coordinate"": 11,
""ice_cream_demand_units"": 2
},
{
""location_id"": 5,
""x_coordinate"": 77,
""y_coordinate"": 36,
""ice_cream_demand_units"": 4
},
{
""location_id"": 6,
""x_coordinate"": 44,
""y_coordinate"": 100,
""ice_cream_demand_units"": 23
},
{
""location_id"": 7,
""x_coordinate"": 100,
""y_coordinate"": 48,
""ice_cream_demand_units"": 4
},
{
""location_id"": 8,
""x_coordinate"": 70,
""y_coordinate"": 80,
""ice_cream_demand_units"": 18
},
{
""location_id"": 9,
""x_coordinate"": 12,
""y_coordinate"": 16,
""ice_cream_demand_units"": 3
},
{
""location_id"": 10,
""x_coordinate"": 93,
""y_coordinate"": 30,
""ice_cream_demand_units"": 10
},
{
""location_id"": 11,
""x_coordinate"": 0,
""y_coordinate"": 32,
""ice_cream_demand_units"": 5
}
],
""cold_storage_node_id"": 0,
""vehicle_freezer_capacity"": 100
}
Also, when you give me the planned runs, a simple JSON reply in this shape works best — something casual like the example below.
{
""solution"": [[cold_storage_id, truck_id, ... , cold_storage_id], [cold_storage_id, truck_id, ... , cold_storage_id], ...]
}
Each inner list is one van’s route: it starts at the cold storage, lists the trucks visited in order, and returns to the cold storage. This JSON is just a sketch of the shape I need — not the actual answer. Please make sure to use the exact identifiers from the instance input when you fill it in (don’t rename or invent new labels).
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[65, 0], [93, 55], [14, 59], [74, 7], [95, 11], [77, 36], [44, 100], [100, 48], [70, 80], [12, 16], [93, 30], [0, 32]], 'depot': 0, 'demands': [0, 24, 9, 17, 2, 4, 23, 4, 18, 3, 10, 5], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 372.3332578741779, 'objective': 372.3332578741779}","[[0, 3, 4, 0], [0, 9, 11, 2, 6, 8, 1, 7, 10, 5, 0]]",372.3332578741779,"{'problem_type': 'CVRP', 'num_nodes': 12, 'nodes': [{'id': 0, 'x': 65, 'y': 0, 'demand': 0}, {'id': 1, 'x': 93, 'y': 55, 'demand': 24}, {'id': 2, 'x': 14, 'y': 59, 'demand': 9}, {'id': 3, 'x': 74, 'y': 7, 'demand': 17}, {'id': 4, 'x': 95, 'y': 11, 'demand': 2}, {'id': 5, 'x': 77, 'y': 36, 'demand': 4}, {'id': 6, 'x': 44, 'y': 100, 'demand': 23}, {'id': 7, 'x': 100, 'y': 48, 'demand': 4}, {'id': 8, 'x': 70, 'y': 80, 'demand': 18}, {'id': 9, 'x': 12, 'y': 16, 'demand': 3}, {'id': 10, 'x': 93, 'y': 30, 'demand': 10}, {'id': 11, 'x': 0, 'y': 32, 'demand': 5}], 'depot': 0, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 372.3332578741779, 'objective': 372.3332578741779}","[[0, 3, 4, 0], [0, 9, 11, 2, 6, 8, 1, 7, 10, 5, 0]]",16,json,0
CVRP,CVRP,"Back at the kitchen the morning routine is to send vans out, have each driver leave and return to base, drop a single meal kit at each subscriber’s address, and never exceed the vehicle’s carrying limit. The practical question is who goes where and in which order so each home is visited once and only once and no van is overloaded. To compare options, simply total up the distance driven by every van — the plan with the smallest total kilometers is the one to use. The concrete details are listed below.
{
""total_locations"": 12,
""nodes"": [
{
""location_id"": 0,
""coord_x"": 30,
""coord_y"": 64,
""kits_required"": 0
},
{
""location_id"": 1,
""coord_x"": 4,
""coord_y"": 45,
""kits_required"": 25
},
{
""location_id"": 2,
""coord_x"": 36,
""coord_y"": 29,
""kits_required"": 11
},
{
""location_id"": 3,
""coord_x"": 100,
""coord_y"": 15,
""kits_required"": 20
},
{
""location_id"": 4,
""coord_x"": 0,
""coord_y"": 48,
""kits_required"": 11
},
{
""location_id"": 5,
""coord_x"": 57,
""coord_y"": 0,
""kits_required"": 6
},
{
""location_id"": 6,
""coord_x"": 69,
""coord_y"": 62,
""kits_required"": 21
},
{
""location_id"": 7,
""coord_x"": 48,
""coord_y"": 100,
""kits_required"": 10
},
{
""location_id"": 8,
""coord_x"": 44,
""coord_y"": 43,
""kits_required"": 22
},
{
""location_id"": 9,
""coord_x"": 8,
""coord_y"": 39,
""kits_required"": 12
},
{
""location_id"": 10,
""coord_x"": 97,
""coord_y"": 20,
""kits_required"": 25
},
{
""location_id"": 11,
""coord_x"": 92,
""coord_y"": 35,
""kits_required"": 10
}
],
""fulfillment_kitchen"": 0,
""van_capacity_kits"": 100
}
Also, to keep things machine-friendly, please lay out your proposed plan in this simple JSON shape so I can parse it easily:
{
""solution"": [[""kitchen_id"", ""subscriber_id"", ... , ""kitchen_id""], [""kitchen_id"", ""subscriber_id"", ... , ""kitchen_id""], ...]
}
Think of ""solution"" as a list of van routes. Each inner list is one van's trip: start at the kitchen_id, visit the subscriber_id placeholders in order, and come back to the kitchen_id. This is just a sketch of the expected shape — don't treat the placeholders as the real labels.
Please use the exact identifiers given in the instance input when you fill this out — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[30, 64], [4, 45], [36, 29], [100, 15], [0, 48], [57, 0], [69, 62], [48, 100], [44, 43], [8, 39], [97, 20], [92, 35]], 'depot': 0, 'demands': [0, 25, 11, 20, 11, 6, 21, 10, 22, 12, 25, 10], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 373.0864707494065, 'objective': 373.0864707494065}","[[0, 8, 2, 9, 1, 4, 0], [0, 7, 6, 11, 10, 3, 5, 0]]",373.0864707494065,"{'problem_type': 'CVRP', 'num_nodes': 12, 'nodes': [{'id': 0, 'x': 30, 'y': 64, 'demand': 0}, {'id': 1, 'x': 4, 'y': 45, 'demand': 25}, {'id': 2, 'x': 36, 'y': 29, 'demand': 11}, {'id': 3, 'x': 100, 'y': 15, 'demand': 20}, {'id': 4, 'x': 0, 'y': 48, 'demand': 11}, {'id': 5, 'x': 57, 'y': 0, 'demand': 6}, {'id': 6, 'x': 69, 'y': 62, 'demand': 21}, {'id': 7, 'x': 48, 'y': 100, 'demand': 10}, {'id': 8, 'x': 44, 'y': 43, 'demand': 22}, {'id': 9, 'x': 8, 'y': 39, 'demand': 12}, {'id': 10, 'x': 97, 'y': 20, 'demand': 25}, {'id': 11, 'x': 92, 'y': 35, 'demand': 10}], 'depot': 0, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 373.0864707494065, 'objective': 373.0864707494065}","[[0, 8, 2, 9, 1, 4, 0], [0, 7, 6, 11, 10, 3, 5, 0]]",17,json,0
CVRP,CVRP,"In our town the plan is to dispatch the blood vans from the hospital, have each one serve a sequence of community sites (no site repeated), return to base, and keep every van’s refrigerator within its capacity. What needs deciding is which sites go together on which trip so that the overall driving — computed by adding up the distance of every route — is as low as it can be. The exact details about stops, demand at each site, and fridge capacities are provided below.
Below are the instance parameters: total_locations_count 15, hospital_node 0, van_refrigerator_capacity 4.
Location 0 at (0, 0) requires 0 units.
Location 1 at (44, 100) requires 1 units.
Location 2 at (62, 43) requires 1 units.
Location 3 at (65, 72) requires 1 units.
Location 4 at (81, 35) requires 1 units.
Location 5 at (95, 75) requires 1 units.
Location 6 at (72, 41) requires 1 units.
Location 7 at (55, 28) requires 1 units.
Location 8 at (15, 6) requires 1 units.
Location 9 at (56, 3) requires 1 units.
Location 10 at (81, 15) requires 1 units.
Location 11 at (52, 12) requires 1 units.
Location 12 at (35, 96) requires 1 units.
Location 13 at (98, 20) requires 1 units.
Location 14 at (100, 29) requires 1 units.
Assign the listed sites to van routes so each van's load ≤ 4 and the sum of route distances is as low as possible.
Also, when you send the actual routes back, a simple JSON layout like this works best — just a list of trips, each trip an ordered list that starts and ends at the hospital:
{
""solution"": [[hospital_id, site_id, ... , hospital_id], [hospital_id, site_id, ... , hospital_id], ...]
}
Think of it like a little form: ""solution"" is the whole set of drives; each inner array is one van’s trip (it should start and end with the hospital ID and list the community site IDs in the order they’re visited). This is just a sketch of the shape I’m expecting, not the real routes.
Please use the exact identifiers from the instance input — don’t rename them or make up new ones. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 0], [44, 100], [62, 43], [65, 72], [81, 35], [95, 75], [72, 41], [55, 28], [15, 6], [56, 3], [81, 15], [52, 12], [35, 96], [98, 20], [100, 29]], 'depot': 0, 'demands': [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'capacity': 4, 'num_vehicles': 4, 'total_distance': 801.6106289172216, 'objective': 801.6106289172216}","[[0, 11, 9, 0], [0, 8, 7, 6, 2, 0], [0, 4, 14, 13, 10, 0], [0, 12, 1, 5, 3, 0]]",801.6106289172216,"{'problem_type': 'CVRP', 'num_nodes': 15, 'nodes': [{'id': 0, 'x': 0, 'y': 0, 'demand': 0}, {'id': 1, 'x': 44, 'y': 100, 'demand': 1}, {'id': 2, 'x': 62, 'y': 43, 'demand': 1}, {'id': 3, 'x': 65, 'y': 72, 'demand': 1}, {'id': 4, 'x': 81, 'y': 35, 'demand': 1}, {'id': 5, 'x': 95, 'y': 75, 'demand': 1}, {'id': 6, 'x': 72, 'y': 41, 'demand': 1}, {'id': 7, 'x': 55, 'y': 28, 'demand': 1}, {'id': 8, 'x': 15, 'y': 6, 'demand': 1}, {'id': 9, 'x': 56, 'y': 3, 'demand': 1}, {'id': 10, 'x': 81, 'y': 15, 'demand': 1}, {'id': 11, 'x': 52, 'y': 12, 'demand': 1}, {'id': 12, 'x': 35, 'y': 96, 'demand': 1}, {'id': 13, 'x': 98, 'y': 20, 'demand': 1}, {'id': 14, 'x': 100, 'y': 29, 'demand': 1}], 'depot': 0, 'capacity': 4, 'num_vehicles': 4, 'total_distance': 801.6106289172216, 'objective': 801.6106289172216}","[[0, 11, 9, 0], [0, 8, 7, 6, 2, 0], [0, 4, 14, 13, 10, 0], [0, 12, 1, 5, 3, 0]]",18,nl,0
CVRP,CVRP,"I run the parts delivery team and my job is to send vans out from the central warehouse so every technician gets the parts they need—once and only once—before the vans return to base. The tricky part is deciding which technicians each van should visit and in what order so that no vehicle leaves with more parts than it can carry and the whole crew drives as few miles as possible; total distance is just the sum of the miles for all of the vans’ round trips. The exact list of technician stops, their part requirements, and the vehicle capacities are shown below.
Here are the 11 locations (warehouse 0) and each van can carry up to 100 parts:
| location_id | x_coordinate_map | y_coordinate_map | parts_required |
|---|---|---|---|
| 0 | 16 | 69 | 0 |
| 1 | 49 | 32 | 2 |
| 2 | 33 | 32 | 7 |
| 3 | 0 | 0 | 25 |
| 4 | 90 | 9 | 18 |
| 5 | 57 | 53 | 3 |
| 6 | 100 | 100 | 18 |
| 7 | 100 | 81 | 2 |
| 8 | 58 | 95 | 23 |
| 9 | 35 | 40 | 22 |
| 10 | 45 | 78 | 5 |
I'll plan routes so no van carries more than 100 parts and every technician is visited exactly once.
Also, when you send the routes back, just stick to this simple JSON layout so it's easy to parse:
{
""solution"": [[depot_id, location_id, ... , depot_id], [depot_id, location_id, ... , depot_id], ...]
}
This just means ""solution"" holds a list of van routes; each route is written as a list that starts and ends with the depot_id and has the technician stops (location_id) in visit order — the ""..."" just shows there can be more stops. It's only a sketch of the expected shape, not the actual answer.
Please make sure you use the exact identifiers from the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[16, 69], [49, 32], [33, 32], [0, 0], [90, 9], [57, 53], [100, 100], [100, 81], [58, 95], [35, 40], [45, 78]], 'depot': 0, 'demands': [0, 2, 7, 25, 18, 3, 18, 2, 23, 22, 5], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 458.9615380288752, 'objective': 458.9615380288752}","[[0, 5, 1, 4, 7, 6, 8, 10, 0], [0, 3, 2, 9, 0]]",458.9615380288752,"{'problem_type': 'CVRP', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 16, 'y': 69, 'demand': 0}, {'id': 1, 'x': 49, 'y': 32, 'demand': 2}, {'id': 2, 'x': 33, 'y': 32, 'demand': 7}, {'id': 3, 'x': 0, 'y': 0, 'demand': 25}, {'id': 4, 'x': 90, 'y': 9, 'demand': 18}, {'id': 5, 'x': 57, 'y': 53, 'demand': 3}, {'id': 6, 'x': 100, 'y': 100, 'demand': 18}, {'id': 7, 'x': 100, 'y': 81, 'demand': 2}, {'id': 8, 'x': 58, 'y': 95, 'demand': 23}, {'id': 9, 'x': 35, 'y': 40, 'demand': 22}, {'id': 10, 'x': 45, 'y': 78, 'demand': 5}], 'depot': 0, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 458.9615380288752, 'objective': 458.9615380288752}","[[0, 5, 1, 4, 7, 6, 8, 10, 0], [0, 3, 2, 9, 0]]",19,markdown_table,0
CVRP,CVRP,"I run a little bakery that sends out a few vans every morning to drop off bread and pastries. The job is to plan which stops each van will make so that every customer gets their delivery exactly once, every driver leaves from the bakery and comes back to the bakery at the end of their run, and no van carries more than it can hold. A better plan is the one that keeps the total driving as low as possible — you figure that total by adding up the miles (or minutes) of all the individual runs. The specific addresses, order sizes, and van limits are shown below.
There are 14 locations in total (the bakery is node 0), and each van can carry up to 100 units.
Location 0 is at coordinates (32, 95) and has an order size of 0.
Location 1 is at coordinates (8, 1) and has an order size of 2.
Location 2 is at coordinates (23, 39) and has an order size of 19.
Location 3 is at coordinates (82, 68) and has an order size of 9.
Location 4 is at coordinates (92, 38) and has an order size of 10.
Location 5 is at coordinates (34, 14) and has an order size of 6.
Location 6 is at coordinates (91, 0) and has an order size of 17.
Location 7 is at coordinates (51, 100) and has an order size of 16.
Location 8 is at coordinates (57, 90) and has an order size of 21.
Location 9 is at coordinates (94, 75) and has an order size of 16.
Location 10 is at coordinates (15, 5) and has an order size of 3.
Location 11 is at coordinates (94, 37) and has an order size of 13.
Location 12 is at coordinates (100, 38) and has an order size of 12.
Location 13 is at coordinates (0, 34) and has an order size of 15.
Use these details to plan routes that serve every customer exactly once and bring each van back to node 0 without exceeding the 100-unit limit.
Also, when you send back a proposed plan, just stick to this simple JSON shape so I can read it easily:
{
""solution"": [[bakery_id, stop_id, ... , bakery_id], [bakery_id, stop_id, ... , bakery_id], ...]
}
This is just a quick sketch of the shape I expect — each inner list is one van’s route: it starts at the bakery, lists the stops that van makes, and returns to the bakery at the end. bakery_id is the placeholder for the bakery/depot identifier from the instance, and stop_id stands in for each customer location identifier. Don’t worry about extra fields or anything fancy — just the routes in that list-of-lists form.
Please make sure every identifier you use matches exactly the ones in the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[32, 95], [8, 1], [23, 39], [82, 68], [92, 38], [34, 14], [91, 0], [51, 100], [57, 90], [94, 75], [15, 5], [94, 37], [100, 38], [0, 34]], 'depot': 0, 'demands': [0, 2, 19, 9, 10, 6, 17, 16, 21, 16, 3, 13, 12, 15], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 474.1959986541846, 'objective': 474.1959986541846}","[[0, 4, 11, 12, 6, 5, 10, 1, 13, 2, 0], [0, 8, 3, 9, 7, 0]]",474.1959986541846,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 0, 'x': 32, 'y': 95, 'demand': 0}, {'id': 1, 'x': 8, 'y': 1, 'demand': 2}, {'id': 2, 'x': 23, 'y': 39, 'demand': 19}, {'id': 3, 'x': 82, 'y': 68, 'demand': 9}, {'id': 4, 'x': 92, 'y': 38, 'demand': 10}, {'id': 5, 'x': 34, 'y': 14, 'demand': 6}, {'id': 6, 'x': 91, 'y': 0, 'demand': 17}, {'id': 7, 'x': 51, 'y': 100, 'demand': 16}, {'id': 8, 'x': 57, 'y': 90, 'demand': 21}, {'id': 9, 'x': 94, 'y': 75, 'demand': 16}, {'id': 10, 'x': 15, 'y': 5, 'demand': 3}, {'id': 11, 'x': 94, 'y': 37, 'demand': 13}, {'id': 12, 'x': 100, 'y': 38, 'demand': 12}, {'id': 13, 'x': 0, 'y': 34, 'demand': 15}], 'depot': 0, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 474.1959986541846, 'objective': 474.1959986541846}","[[0, 4, 11, 12, 6, 5, 10, 1, 13, 2, 0], [0, 8, 3, 9, 7, 0]]",20,nl,0
CVRP,CVRP,"Out on the dairy route, the problem is deciding which farms to group into each haul and in what sequence so the truck can head out from the silo, visit every farm one time, and come back for the next load without ever taking on more milk than it can handle. The better the plan, the less total driving across all those runs — total driving is computed by adding up the length of each trip. The exact farm list, their milk amounts, and truck capacity are shown below.
There are 15 total locations, the silo is node A, and the truck capacity is 100.
| location_id | map_x_coordinate | map_y_coordinate | milk_volume_demand |
|---|---|---|---|
| A | 82 | 35 | 0 |
| B | 75 | 91 | 23 |
| C | 43 | 15 | 3 |
| D | 61 | 74 | 24 |
| E | 61 | 70 | 7 |
| F | 23 | 9 | 13 |
| G | 48 | 57 | 14 |
| H | 70 | 67 | 13 |
| I | 39 | 4 | 24 |
| J | 75 | 100 | 24 |
| K | 100 | 28 | 20 |
| L | 73 | 76 | 12 |
| M | 20 | 83 | 4 |
| N | 0 | 57 | 15 |
| O | 61 | 0 | 1 |
Plan trips so each farm is visited once and no trip carries more than the truck capacity 100.
Oh, and when you send the plan back, just use this simple JSON layout so I can read the routes easily:
{
""solution"": [[""depot_id"", ""location_id"", ... , ""depot_id""], [""depot_id"", ""location_id"", ... , ""depot_id""], ...]
}
Think of ""solution"" as a list of runs. Each inner list is one truck trip: start at the depot, visit the farms in order (each shown by its identifier), and come back to the depot. This block is just a sketch of the shape I expect—not the actual answer.
Please use the exact identifiers from the instance input — don’t rename them or make up new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”. ""","{'coordinates': [[82, 35], [75, 91], [43, 15], [61, 74], [61, 70], [23, 9], [48, 57], [70, 67], [39, 4], [75, 100], [100, 28], [73, 76], [20, 83], [0, 57], [61, 0]], 'depot': 0, 'demands': [0, 23, 3, 24, 7, 13, 14, 13, 24, 24, 20, 12, 4, 15, 1], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 449.46139758071087, 'objective': 449.46139758071087}","[[0, 6, 3, 9, 1, 11, 0], [0, 7, 4, 12, 13, 5, 8, 2, 14, 10, 0]]",449.46139758071087,"{'problem_type': 'CVRP', 'num_nodes': 15, 'nodes': [{'id': 'A', 'x': 82, 'y': 35, 'demand': 0}, {'id': 'B', 'x': 75, 'y': 91, 'demand': 23}, {'id': 'C', 'x': 43, 'y': 15, 'demand': 3}, {'id': 'D', 'x': 61, 'y': 74, 'demand': 24}, {'id': 'E', 'x': 61, 'y': 70, 'demand': 7}, {'id': 'F', 'x': 23, 'y': 9, 'demand': 13}, {'id': 'G', 'x': 48, 'y': 57, 'demand': 14}, {'id': 'H', 'x': 70, 'y': 67, 'demand': 13}, {'id': 'I', 'x': 39, 'y': 4, 'demand': 24}, {'id': 'J', 'x': 75, 'y': 100, 'demand': 24}, {'id': 'K', 'x': 100, 'y': 28, 'demand': 20}, {'id': 'L', 'x': 73, 'y': 76, 'demand': 12}, {'id': 'M', 'x': 20, 'y': 83, 'demand': 4}, {'id': 'N', 'x': 0, 'y': 57, 'demand': 15}, {'id': 'O', 'x': 61, 'y': 0, 'demand': 1}], 'depot': 'A', 'capacity': 100, 'num_vehicles': 2, 'total_distance': 449.46139758071087, 'objective': 449.46139758071087}","[['A', 'G', 'D', 'J', 'B', 'L', 'A'], ['A', 'H', 'E', 'M', 'N', 'F', 'I', 'C', 'O', 'K', 'A']]",21,markdown_table,names
CVRP,CVRP,"Back at the warehouse the morning plan is simple to explain: make a collection of round trips that start and end at the distribution center and make sure every vending machine gets one visit and only one. The decisions are grouping the stops into trips and loading each trip within the vehicle’s capacity so nothing is missed or doubled up. The winning plan is the one that results in the least overall driving — total distance is computed by summing every trip’s length. The concrete instance details follow below.
It specifies 14 locations including depot 1 and a vehicle capacity of 160.
Location 1 at (0, 31) requires 0 units.
Location 2 at (21, 60) requires 7 units.
Location 3 at (3, 83) requires 23 units.
Location 4 at (67, 14) requires 11 units.
Location 5 at (36, 33) requires 19 units.
Location 6 at (67, 33) requires 15 units.
Location 7 at (97, 36) requires 8 units.
Location 8 at (36, 71) requires 8 units.
Location 9 at (39, 95) requires 14 units.
Location 10 at (85, 0) requires 19 units.
Location 11 at (24, 45) requires 12 units.
Location 12 at (97, 86) requires 17 units.
Location 13 at (100, 100) requires 6 units.
Location 14 at (79, 24) requires 10 units.
Every trip must start and end at 1, respect the vehicle capacity of 160, and together cover all 14 locations exactly once.
Also, when you hand over the plan, a short JSON snippet like this makes it easy to read and check:
{
""solution"": [[warehouse_id, machine_id, ... , warehouse_id], [warehouse_id, machine_id, ... , warehouse_id], ...]
}
This just means ""solution"" contains a list of round trips. Each inner list is one trip that starts and ends at the distribution center (here shown as warehouse_id) and lists the stops you visit in order (machine_id placeholders). It's just a sketch of the shape I expect — not the real answer.
Please make sure to use the exact identifiers from the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 31], [21, 60], [3, 83], [67, 14], [36, 33], [67, 33], [97, 36], [36, 71], [39, 95], [85, 0], [24, 45], [97, 86], [100, 100], [79, 24]], 'depot': 0, 'demands': [0, 7, 23, 11, 19, 15, 8, 8, 14, 19, 12, 17, 6, 10], 'capacity': 160, 'num_vehicles': 2, 'total_distance': 460.40361346466153, 'objective': 460.40361346466153}","[[0, 10, 0], [0, 4, 5, 3, 9, 13, 6, 11, 12, 8, 7, 1, 2, 0]]",460.40361346466153,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 1, 'x': 0, 'y': 31, 'demand': 0}, {'id': 2, 'x': 21, 'y': 60, 'demand': 7}, {'id': 3, 'x': 3, 'y': 83, 'demand': 23}, {'id': 4, 'x': 67, 'y': 14, 'demand': 11}, {'id': 5, 'x': 36, 'y': 33, 'demand': 19}, {'id': 6, 'x': 67, 'y': 33, 'demand': 15}, {'id': 7, 'x': 97, 'y': 36, 'demand': 8}, {'id': 8, 'x': 36, 'y': 71, 'demand': 8}, {'id': 9, 'x': 39, 'y': 95, 'demand': 14}, {'id': 10, 'x': 85, 'y': 0, 'demand': 19}, {'id': 11, 'x': 24, 'y': 45, 'demand': 12}, {'id': 12, 'x': 97, 'y': 86, 'demand': 17}, {'id': 13, 'x': 100, 'y': 100, 'demand': 6}, {'id': 14, 'x': 79, 'y': 24, 'demand': 10}], 'depot': 1, 'capacity': 160, 'num_vehicles': 2, 'total_distance': 460.40361346466153, 'objective': 460.40361346466153}","[[1, 11, 1], [1, 5, 6, 4, 10, 14, 7, 12, 13, 9, 8, 2, 3, 1]]",22,nl,1
CVRP,CVRP,"On a busy morning the dispatch desk needs to parcel out deliveries: bundle clinic stops into routes so each clinic gets exactly one delivery, every driver departs from and returns to the pharmacy, and each vehicle stays within its load allowance. The clear measure of success is the least amount of driving across the fleet — total mileage equals the sum of the distances of all routes. The full list of locations, demands, and vehicle capacities is given below.
Below are 11 locations: the pharmacy is node 0 and vehicle capacity is 100.
| location_id | x_coordinate | y_coordinate | clinic_demand |
|---|---|---|---|
| 0 | 61 | 100 | 0 |
| 1 | 31 | 72 | 23 |
| 2 | 53 | 12 | 12 |
| 3 | 17 | 67 | 6 |
| 4 | 0 | 26 | 14 |
| 5 | 31 | 100 | 18 |
| 6 | 33 | 0 | 12 |
| 7 | 33 | 16 | 25 |
| 8 | 44 | 74 | 17 |
| 9 | 89 | 56 | 2 |
| 10 | 100 | 16 | 11 |
Assign each clinic exactly once, start and end every route at the pharmacy 0, respect the capacity 100, and minimize total fleet mileage.
When you send the routes back, just stick to this simple JSON layout so it's easy to plug into the dispatcher:
{
""solution"": [[""pharmacy_id"", ""clinic_id"", ..., ""pharmacy_id""], [""pharmacy_id"", ""clinic_id"", ..., ""pharmacy_id""], ...]
}
Think of it like a form: ""solution"" holds a list of routes; each route is an ordered list that starts and ends at the pharmacy and lists the clinic stops in the order the driver will visit them. This block is just a sketch of the expected shape — not the actual answer.
Please make sure to use the exact identifiers given in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[61, 100], [31, 72], [53, 12], [17, 67], [0, 26], [31, 100], [33, 0], [33, 16], [44, 74], [89, 56], [100, 16]], 'depot': 0, 'demands': [0, 23, 12, 6, 14, 18, 12, 25, 17, 2, 11], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 410.0996921353664, 'objective': 410.0996921353664}","[[0, 8, 1, 0], [0, 5, 3, 4, 7, 6, 2, 10, 9, 0]]",410.0996921353664,"{'problem_type': 'CVRP', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 61, 'y': 100, 'demand': 0}, {'id': 1, 'x': 31, 'y': 72, 'demand': 23}, {'id': 2, 'x': 53, 'y': 12, 'demand': 12}, {'id': 3, 'x': 17, 'y': 67, 'demand': 6}, {'id': 4, 'x': 0, 'y': 26, 'demand': 14}, {'id': 5, 'x': 31, 'y': 100, 'demand': 18}, {'id': 6, 'x': 33, 'y': 0, 'demand': 12}, {'id': 7, 'x': 33, 'y': 16, 'demand': 25}, {'id': 8, 'x': 44, 'y': 74, 'demand': 17}, {'id': 9, 'x': 89, 'y': 56, 'demand': 2}, {'id': 10, 'x': 100, 'y': 16, 'demand': 11}], 'depot': 0, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 410.0996921353664, 'objective': 410.0996921353664}","[[0, 8, 1, 0], [0, 5, 3, 4, 7, 6, 2, 10, 9, 0]]",23,markdown_table,0
CVRP,CVRP,"I run the logistics side of a grocery wholesaler and the job is to plan pickup-and-delivery loops from our central depot to a bunch of stores. The choice to make is which stores go on which truck and in what order, making sure every store gets its delivery once and only once, each truck leaves the depot and comes back to it, and no truck is loaded beyond what it can safely carry. A better plan is the one where all the trucks together drive the fewest miles — you figure that by adding up the distance each truck travels on its route. The exact list of stores, how much they need, and the truck capacities are shown below.
# total_locations_including_depot=15
# central_depot_id=0
# truck_capacity_units=100
location_node_id,map_x_coordinate,map_y_coordinate,store_demand_units
0,30,65,0
1,6,46,25
2,83,45,20
3,37,57,10
4,55,0,6
5,0,55,19
6,58,100,15
7,12,52,15
8,55,5,18
9,83,4,13
10,45,4,3
11,100,78,10
12,76,67,12
13,75,71,5
14,42,21,11
Also, I'll hand the plan back in a simple JSON shape so it's easy to plug into other tools or maps. It follows this layout:
{
""solution"": [[depot_id, location_id, ... , depot_id], [depot_id, location_id, ... , depot_id], ...]
}
Think of ""solution"" as just a list of routes. Each route is a list that starts at the depot, lists the store locations visited in order, and ends back at the depot. This little JSON is just a sketch of the shape I’ll deliver in — it’s not the actual routes yet.
Please use the exact identifiers from the problem input when we fill this in — don't rename any locations or invent new labels.
- for example: Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'coordinates': [[30, 65], [6, 46], [83, 45], [37, 57], [55, 0], [0, 55], [58, 100], [12, 52], [55, 5], [83, 4], [45, 4], [100, 78], [76, 67], [75, 71], [42, 21]], 'depot': 0, 'demands': [0, 25, 20, 10, 6, 19, 15, 15, 18, 13, 3, 10, 12, 5, 11], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 429.34298729082184, 'objective': 429.34298729082184}","[[0, 14, 10, 8, 4, 9, 2, 11, 12, 13, 0], [0, 6, 3, 7, 1, 5, 0]]",429.34298729082184,"{'problem_type': 'CVRP', 'num_nodes': 15, 'nodes': [{'id': 0, 'x': 30, 'y': 65, 'demand': 0}, {'id': 1, 'x': 6, 'y': 46, 'demand': 25}, {'id': 2, 'x': 83, 'y': 45, 'demand': 20}, {'id': 3, 'x': 37, 'y': 57, 'demand': 10}, {'id': 4, 'x': 55, 'y': 0, 'demand': 6}, {'id': 5, 'x': 0, 'y': 55, 'demand': 19}, {'id': 6, 'x': 58, 'y': 100, 'demand': 15}, {'id': 7, 'x': 12, 'y': 52, 'demand': 15}, {'id': 8, 'x': 55, 'y': 5, 'demand': 18}, {'id': 9, 'x': 83, 'y': 4, 'demand': 13}, {'id': 10, 'x': 45, 'y': 4, 'demand': 3}, {'id': 11, 'x': 100, 'y': 78, 'demand': 10}, {'id': 12, 'x': 76, 'y': 67, 'demand': 12}, {'id': 13, 'x': 75, 'y': 71, 'demand': 5}, {'id': 14, 'x': 42, 'y': 21, 'demand': 11}], 'depot': 0, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 429.34298729082184, 'objective': 429.34298729082184}","[[0, 14, 10, 8, 4, 9, 2, 11, 12, 13, 0], [0, 6, 3, 7, 1, 5, 0]]",24,csv,0
CVRP,CVRP,"We need to map out routes for a recycling crew leaving from the central depot so each collection spot is collected exactly one time and every route loops back to the depot. The teams must be assigned so that the load picked up on any single loop never exceeds that truck’s capacity, and the whole day's travel should be as short as possible — the total distance is just the sum of all individual trip distances. Nothing can be skipped or doubled up. The exact addresses, quantities, and vehicle sizes are listed below.
There are 15 locations in total (including headquarters node 1), and each truck's capacity is 100.
We will collect 0 units at location 1 located at (52, 59).
We will collect 18 units at location 2 located at (19, 20).
We will collect 21 units at location 3 located at (80, 15).
We will collect 29 units at location 4 located at (26, 100).
We will collect 31 units at location 5 located at (93, 96).
We will collect 19 units at location 6 located at (17, 50).
We will collect 20 units at location 7 located at (39, 67).
We will collect 22 units at location 8 located at (100, 2).
We will collect 28 units at location 9 located at (59, 0).
We will collect 18 units at location 10 located at (54, 72).
We will collect 22 units at location 11 located at (57, 28).
We will collect 18 units at location 12 located at (7, 13).
We will collect 21 units at location 13 located at (70, 37).
We will collect 27 units at location 14 located at (72, 63).
We will collect 5 units at location 15 located at (0, 54).
We will assign routes so each spot is visited exactly once, every route starts and ends at node 1, and no route's load exceeds 100.
Also, when you hand me the routes, just stick to this simple JSON layout so it's easy to read and validate:
{
""solution"": [[depot_id, location_id, ... , depot_id], [depot_id, location_id, ... , depot_id], ...]
}
This shows a ""solution"" as a list of routes. Each route is itself a list of stops that starts and ends with the depot_id; the middle entries are the collection locations on that loop. Think of it like filling out a little route card for each truck — nothing fancy, just the order of stops.
This JSON is just a sketch of the shape I expect, not the actual answer. Please make sure to use the exact identifiers from the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[52, 59], [19, 20], [80, 15], [26, 100], [93, 96], [17, 50], [39, 67], [100, 2], [59, 0], [54, 72], [57, 28], [7, 13], [70, 37], [72, 63], [0, 54]], 'depot': 0, 'demands': [0, 18, 21, 29, 31, 19, 20, 22, 28, 18, 22, 18, 21, 27, 5], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 640.468438392501, 'objective': 640.468438392501}","[[0, 10, 1, 11, 14, 5, 9, 0], [0, 6, 4, 13, 12, 0], [0, 3, 8, 7, 2, 0]]",640.468438392501,"{'problem_type': 'CVRP', 'num_nodes': 15, 'nodes': [{'id': 1, 'x': 52, 'y': 59, 'demand': 0}, {'id': 2, 'x': 19, 'y': 20, 'demand': 18}, {'id': 3, 'x': 80, 'y': 15, 'demand': 21}, {'id': 4, 'x': 26, 'y': 100, 'demand': 29}, {'id': 5, 'x': 93, 'y': 96, 'demand': 31}, {'id': 6, 'x': 17, 'y': 50, 'demand': 19}, {'id': 7, 'x': 39, 'y': 67, 'demand': 20}, {'id': 8, 'x': 100, 'y': 2, 'demand': 22}, {'id': 9, 'x': 59, 'y': 0, 'demand': 28}, {'id': 10, 'x': 54, 'y': 72, 'demand': 18}, {'id': 11, 'x': 57, 'y': 28, 'demand': 22}, {'id': 12, 'x': 7, 'y': 13, 'demand': 18}, {'id': 13, 'x': 70, 'y': 37, 'demand': 21}, {'id': 14, 'x': 72, 'y': 63, 'demand': 27}, {'id': 15, 'x': 0, 'y': 54, 'demand': 5}], 'depot': 1, 'capacity': 100, 'num_vehicles': 3, 'total_distance': 640.468438392501, 'objective': 640.468438392501}","[[1, 11, 2, 12, 15, 6, 10, 1], [1, 7, 5, 14, 13, 1], [1, 4, 9, 8, 3, 1]]",25,nl,1
CVRP,CVRP,"Recently the outreach team asked for a clean way to schedule mobile donation visits: split the community stops into runs that start and end at the clinic, make sure each stop gets one visit only, and don’t overload any van beyond its seating or storage. The winning schedule is the one with the smallest total driving distance — just add together all the route lengths to see which is shortest. The detailed list of stops and capacities is shown below.
{
""total_locations"": 14,
""nodes"": [
{
""location_id"": ""A"",
""x_coord"": 95,
""y_coord"": 72,
""expected_donors"": 0
},
{
""location_id"": ""B"",
""x_coord"": 100,
""y_coord"": 70,
""expected_donors"": 90
},
{
""location_id"": ""C"",
""x_coord"": 32,
""y_coord"": 13,
""expected_donors"": 73
},
{
""location_id"": ""D"",
""x_coord"": 10,
""y_coord"": 52,
""expected_donors"": 7
},
{
""location_id"": ""E"",
""x_coord"": 72,
""y_coord"": 69,
""expected_donors"": 11
},
{
""location_id"": ""F"",
""x_coord"": 50,
""y_coord"": 26,
""expected_donors"": 89
},
{
""location_id"": ""G"",
""x_coord"": 58,
""y_coord"": 100,
""expected_donors"": 41
},
{
""location_id"": ""H"",
""x_coord"": 80,
""y_coord"": 45,
""expected_donors"": 15
},
{
""location_id"": ""I"",
""x_coord"": 100,
""y_coord"": 80,
""expected_donors"": 49
},
{
""location_id"": ""J"",
""x_coord"": 38,
""y_coord"": 5,
""expected_donors"": 55
},
{
""location_id"": ""K"",
""x_coord"": 34,
""y_coord"": 73,
""expected_donors"": 44
},
{
""location_id"": ""L"",
""x_coord"": 47,
""y_coord"": 0,
""expected_donors"": 99
},
{
""location_id"": ""M"",
""x_coord"": 96,
""y_coord"": 26,
""expected_donors"": 23
},
{
""location_id"": ""N"",
""x_coord"": 0,
""y_coord"": 65,
""expected_donors"": 62
}
],
""clinic_id"": ""A"",
""van_capacity"": 428
}
Oh, and when you hand the schedule back, please use this simple JSON shape so it's easy to parse:
{
""solution"": [[clinic_id, stop_id, ... , clinic_id], [clinic_id, stop_id, ... , clinic_id], ...]
}
""solution"" is just a list of runs. Each inner list is one run that starts and ends at the clinic (that's the first and last placeholder), with the stops visited in between. It's just a quick sketch of the format I need — not the actual answer.
Please use the exact identifiers from the instance input when filling this in — do not rename them or add new labels. For example: Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'coordinates': [[95, 72], [100, 70], [32, 13], [10, 52], [72, 69], [50, 26], [58, 100], [80, 45], [100, 80], [38, 5], [34, 73], [47, 0], [96, 26], [0, 65]], 'depot': 0, 'demands': [0, 90, 73, 7, 11, 89, 41, 15, 49, 55, 44, 99, 23, 62], 'capacity': 428, 'num_vehicles': 2, 'total_distance': 447.21998641223024, 'objective': 447.21998641223024}","[[0, 12, 11, 9, 2, 5, 7, 0], [0, 1, 8, 6, 10, 13, 3, 4, 0]]",447.21998641223024,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 95, 'y': 72, 'demand': 0}, {'id': 'B', 'x': 100, 'y': 70, 'demand': 90}, {'id': 'C', 'x': 32, 'y': 13, 'demand': 73}, {'id': 'D', 'x': 10, 'y': 52, 'demand': 7}, {'id': 'E', 'x': 72, 'y': 69, 'demand': 11}, {'id': 'F', 'x': 50, 'y': 26, 'demand': 89}, {'id': 'G', 'x': 58, 'y': 100, 'demand': 41}, {'id': 'H', 'x': 80, 'y': 45, 'demand': 15}, {'id': 'I', 'x': 100, 'y': 80, 'demand': 49}, {'id': 'J', 'x': 38, 'y': 5, 'demand': 55}, {'id': 'K', 'x': 34, 'y': 73, 'demand': 44}, {'id': 'L', 'x': 47, 'y': 0, 'demand': 99}, {'id': 'M', 'x': 96, 'y': 26, 'demand': 23}, {'id': 'N', 'x': 0, 'y': 65, 'demand': 62}], 'depot': 'A', 'capacity': 428, 'num_vehicles': 2, 'total_distance': 447.21998641223024, 'objective': 447.21998641223024}","[['A', 'M', 'L', 'J', 'C', 'F', 'H', 'A'], ['A', 'B', 'I', 'G', 'K', 'N', 'D', 'E', 'A']]",26,json,names
CVRP,CVRP,"We need a straightforward pickup schedule: assign which truck goes to which compost sites so every site is covered once, every run starts and ends at the yard, and no truck is overloaded. The winning schedule is the one with the least total driving distance — you get that by summing the length of every truck’s route from the yard out through its stops and back again. Concrete details about the locations, their amounts, and the truck limits follow below.
We have 12 total locations including the yard A, and a truck capacity of 66.
Site A at (48, 57) requires 0 units that we must collect.
Site B at (3, 12) requires 10 units that we must collect.
Site C at (100, 0) requires 7 units that we must collect.
Site D at (13, 54) requires 6 units that we must collect.
Site E at (83, 20) requires 10 units that we must collect.
Site F at (25, 41) requires 6 units that we must collect.
Site G at (95, 27) requires 8 units that we must collect.
Site H at (83, 56) requires 9 units that we must collect.
Site I at (52, 95) requires 5 units that we must collect.
Site J at (60, 68) requires 8 units that we must collect.
Site K at (0, 100) requires 5 units that we must collect.
Site L at (88, 14) requires 7 units that we must collect.
We will assign truck routes that cover every site once, start and end at the yard, respect the truck capacity, and minimize total driving distance.
Also, when you send the actual plan back, keep it in this simple JSON layout so it's easy to read and check:
{
""solution"": [[yard_id, site_id, ... , yard_id], [yard_id, site_id, ... , yard_id], ...]
}
Think of ""solution"" as a list of runs. Each run is a list that starts and ends at the yard, with the compost sites visited in between — those placeholders just show the shape, not the real IDs or the final routes. This is only a sketch of the expected format, not the finished answer.
Please use the exact identifiers from the instance input — don't rename them or invent new labels.
- Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[48, 57], [3, 12], [100, 0], [13, 54], [83, 20], [25, 41], [95, 27], [83, 56], [52, 95], [60, 68], [0, 100], [88, 14]], 'depot': 0, 'demands': [0, 10, 7, 6, 10, 6, 8, 9, 5, 8, 5, 7], 'capacity': 66, 'num_vehicles': 2, 'total_distance': 423.1117664144992, 'objective': 423.1117664144992}","[[0, 7, 6, 2, 11, 4, 0], [0, 5, 1, 3, 10, 8, 9, 0]]",423.1117664144992,"{'problem_type': 'CVRP', 'num_nodes': 12, 'nodes': [{'id': 'A', 'x': 48, 'y': 57, 'demand': 0}, {'id': 'B', 'x': 3, 'y': 12, 'demand': 10}, {'id': 'C', 'x': 100, 'y': 0, 'demand': 7}, {'id': 'D', 'x': 13, 'y': 54, 'demand': 6}, {'id': 'E', 'x': 83, 'y': 20, 'demand': 10}, {'id': 'F', 'x': 25, 'y': 41, 'demand': 6}, {'id': 'G', 'x': 95, 'y': 27, 'demand': 8}, {'id': 'H', 'x': 83, 'y': 56, 'demand': 9}, {'id': 'I', 'x': 52, 'y': 95, 'demand': 5}, {'id': 'J', 'x': 60, 'y': 68, 'demand': 8}, {'id': 'K', 'x': 0, 'y': 100, 'demand': 5}, {'id': 'L', 'x': 88, 'y': 14, 'demand': 7}], 'depot': 'A', 'capacity': 66, 'num_vehicles': 2, 'total_distance': 423.1117664144992, 'objective': 423.1117664144992}","[['A', 'H', 'G', 'C', 'L', 'E', 'A'], ['A', 'F', 'B', 'D', 'K', 'I', 'J', 'A']]",27,nl,names
CVRP,CVRP,"Someone on the logistics team needs to assign which truck goes to which gigs this weekend. The plan must make sure every venue gets its gear exactly once, every truck starts out from the depot and returns there when it’s done, and loads never exceed a truck’s weight limit. The simplest way to judge a plan is by total driving distance — total it up by summing each truck’s route, and the lower the total the better. The exact orders, weights, and truck capacities are detailed below.
# total_locations_including_depot=11
# depot_location_id=1
# vehicle_capacity_weight=110
location_id,x_coordinate,y_coordinate,order_weight
1,0,0,0
2,51,50,7
3,3,21,10
4,42,40,9
5,42,34,7
6,27,28,5
7,100,6,8
8,12,11,8
9,98,100,8
10,34,59,6
11,48,32,7
Oh, and one more thing — when you send the plan back, please use this simple JSON layout so it's easy to read and check:
{
""solution"": [[depot_id, location_id, ... , depot_id], [depot_id, location_id, ... , depot_id], ...]
}
Think of it like a form: each inner list is one truck's trip (start at the depot, visit the venues in order, come back to the depot), and the outer list is the set of all trucks/routes. The placeholders (like depot_id and location_id) stand for the actual identifiers you'll use for the depot and the venues.
This is just a sketch of the shape I want, not the actual answers — fill it with the real IDs from the instance when you reply. Please make sure all identifiers are used exactly as they appear in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 0], [51, 50], [3, 21], [42, 40], [42, 34], [27, 28], [100, 6], [12, 11], [98, 100], [34, 59], [48, 32]], 'depot': 0, 'demands': [0, 7, 10, 9, 7, 5, 8, 8, 8, 6, 7], 'capacity': 110, 'num_vehicles': 1, 'total_distance': 380.7548990249999, 'objective': 380.7548990249999}","[[0, 7, 5, 3, 4, 10, 6, 8, 1, 9, 2, 0]]",380.7548990249999,"{'problem_type': 'CVRP', 'num_nodes': 11, 'nodes': [{'id': 1, 'x': 0, 'y': 0, 'demand': 0}, {'id': 2, 'x': 51, 'y': 50, 'demand': 7}, {'id': 3, 'x': 3, 'y': 21, 'demand': 10}, {'id': 4, 'x': 42, 'y': 40, 'demand': 9}, {'id': 5, 'x': 42, 'y': 34, 'demand': 7}, {'id': 6, 'x': 27, 'y': 28, 'demand': 5}, {'id': 7, 'x': 100, 'y': 6, 'demand': 8}, {'id': 8, 'x': 12, 'y': 11, 'demand': 8}, {'id': 9, 'x': 98, 'y': 100, 'demand': 8}, {'id': 10, 'x': 34, 'y': 59, 'demand': 6}, {'id': 11, 'x': 48, 'y': 32, 'demand': 7}], 'depot': 1, 'capacity': 110, 'num_vehicles': 1, 'total_distance': 380.7548990249999, 'objective': 380.7548990249999}","[[1, 8, 6, 4, 5, 11, 7, 9, 2, 10, 3, 1]]",28,csv,1
CVRP,CVRP,"There’s a courier team that runs morning drops out of the sorting office and the challenge is to draw up routes so every mailbox is covered exactly once. Each trip has to leave and return to the sorting office, a vehicle can’t be packed beyond its carrying limit, and the whole set of trips should rack up as few miles as possible — that is checked by summing the distance of every route. The specific stops and mail loads are shown below.
{
""total_locations"": 13,
""nodes"": [
{
""location_id"": ""A"",
""x_coordinate_miles"": 53,
""y_coordinate_miles"": 47,
""mail_demand"": 0
},
{
""location_id"": ""B"",
""x_coordinate_miles"": 12,
""y_coordinate_miles"": 36,
""mail_demand"": 1
},
{
""location_id"": ""C"",
""x_coordinate_miles"": 100,
""y_coordinate_miles"": 36,
""mail_demand"": 1
},
{
""location_id"": ""D"",
""x_coordinate_miles"": 2,
""y_coordinate_miles"": 100,
""mail_demand"": 1
},
{
""location_id"": ""E"",
""x_coordinate_miles"": 9,
""y_coordinate_miles"": 53,
""mail_demand"": 1
},
{
""location_id"": ""F"",
""x_coordinate_miles"": 75,
""y_coordinate_miles"": 21,
""mail_demand"": 1
},
{
""location_id"": ""G"",
""x_coordinate_miles"": 54,
""y_coordinate_miles"": 19,
""mail_demand"": 1
},
{
""location_id"": ""H"",
""x_coordinate_miles"": 81,
""y_coordinate_miles"": 77,
""mail_demand"": 1
},
{
""location_id"": ""I"",
""x_coordinate_miles"": 31,
""y_coordinate_miles"": 15,
""mail_demand"": 1
},
{
""location_id"": ""J"",
""x_coordinate_miles"": 29,
""y_coordinate_miles"": 0,
""mail_demand"": 1
},
{
""location_id"": ""K"",
""x_coordinate_miles"": 86,
""y_coordinate_miles"": 86,
""mail_demand"": 1
},
{
""location_id"": ""L"",
""x_coordinate_miles"": 0,
""y_coordinate_miles"": 35,
""mail_demand"": 1
},
{
""location_id"": ""M"",
""x_coordinate_miles"": 48,
""y_coordinate_miles"": 32,
""mail_demand"": 1
}
],
""sorting_office_id"": ""A"",
""vehicle_capacity_mail_units"": 12
}
When you send the routes back, just use this simple JSON layout so it's easy to read and plug into the system:
{
""solution"": [[sorting_office_id, mailbox_id, ... , sorting_office_id], [sorting_office_id, mailbox_id, ... , sorting_office_id], ...]
}
This is just a sketch of the shape I expect: ""solution"" is the list of trips, each inner list is one round trip that starts and ends at the sorting office, and the placeholders (like sorting_office_id and mailbox_id) show where you'll drop in the actual stop IDs from the instance. It's an example, not the real answer — plug in the real identifiers for each stop.
Please make sure to use the identifiers exactly as they appear in the instance input — don't rename them and don't invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[53, 47], [12, 36], [100, 36], [2, 100], [9, 53], [75, 21], [54, 19], [81, 77], [31, 15], [29, 0], [86, 86], [0, 35], [48, 32]], 'depot': 0, 'demands': [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'capacity': 12, 'num_vehicles': 1, 'total_distance': 388.52315250814627, 'objective': 388.52315250814627}","[[0, 12, 6, 9, 8, 1, 11, 4, 3, 10, 7, 2, 5, 0]]",388.52315250814627,"{'problem_type': 'CVRP', 'num_nodes': 13, 'nodes': [{'id': 'A', 'x': 53, 'y': 47, 'demand': 0}, {'id': 'B', 'x': 12, 'y': 36, 'demand': 1}, {'id': 'C', 'x': 100, 'y': 36, 'demand': 1}, {'id': 'D', 'x': 2, 'y': 100, 'demand': 1}, {'id': 'E', 'x': 9, 'y': 53, 'demand': 1}, {'id': 'F', 'x': 75, 'y': 21, 'demand': 1}, {'id': 'G', 'x': 54, 'y': 19, 'demand': 1}, {'id': 'H', 'x': 81, 'y': 77, 'demand': 1}, {'id': 'I', 'x': 31, 'y': 15, 'demand': 1}, {'id': 'J', 'x': 29, 'y': 0, 'demand': 1}, {'id': 'K', 'x': 86, 'y': 86, 'demand': 1}, {'id': 'L', 'x': 0, 'y': 35, 'demand': 1}, {'id': 'M', 'x': 48, 'y': 32, 'demand': 1}], 'depot': 'A', 'capacity': 12, 'num_vehicles': 1, 'total_distance': 388.52315250814627, 'objective': 388.52315250814627}","[['A', 'M', 'G', 'J', 'I', 'B', 'L', 'E', 'D', 'K', 'H', 'C', 'F', 'A']]",29,json,names
CVRP,CVRP,"Back at the office the crew needs to map out supply runs so each build site gets a single delivery, with every trip launching from the yard and finishing there, and no vehicle carrying more than it’s rated for. The key comparison between different plans is how much driving they cause: take each route’s distance, add them up, and the lower that grand total the better the plan. The full instance details — which sites, how much material, and vehicle capacities — are listed below.
# total_locations_including_yard=11
# yard_node_id=0
# vehicle_capacity=100
location_id,x_coord,y_coord,material_demand
0,100,21,0
1,55,82,10
2,52,51,23
3,43,26,2
4,95,85,16
5,89,100,23
6,57,95,21
7,82,0,3
8,5,51,26
9,14,21,22
10,0,8,8
Also, when you send the plan back, just use this simple JSON layout so I can read the routes programmatically — nothing fancy needed:
{
""solution"": [[yard_id, site_id, ... , yard_id], [yard_id, site_id, ... , yard_id], ...]
}
This just means: ""solution"" is a list of routes, each route is a list that starts and ends at the yard and lists the sites visited in order. Think of it like filling out a form where each row is one round-trip from the yard to a few sites and back.
This JSON is only a sketch of the expected shape — not the actual answer.
Please make sure you use the exact identifiers from the instance input, with no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[100, 21], [55, 82], [52, 51], [43, 26], [95, 85], [89, 100], [57, 95], [82, 0], [5, 51], [14, 21], [0, 8]], 'depot': 0, 'demands': [0, 10, 23, 2, 16, 23, 21, 3, 26, 22, 8], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 471.6513598593217, 'objective': 471.6513598593217}","[[0, 2, 8, 10, 9, 3, 7, 0], [0, 1, 6, 5, 4, 0]]",471.6513598593217,"{'problem_type': 'CVRP', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 100, 'y': 21, 'demand': 0}, {'id': 1, 'x': 55, 'y': 82, 'demand': 10}, {'id': 2, 'x': 52, 'y': 51, 'demand': 23}, {'id': 3, 'x': 43, 'y': 26, 'demand': 2}, {'id': 4, 'x': 95, 'y': 85, 'demand': 16}, {'id': 5, 'x': 89, 'y': 100, 'demand': 23}, {'id': 6, 'x': 57, 'y': 95, 'demand': 21}, {'id': 7, 'x': 82, 'y': 0, 'demand': 3}, {'id': 8, 'x': 5, 'y': 51, 'demand': 26}, {'id': 9, 'x': 14, 'y': 21, 'demand': 22}, {'id': 10, 'x': 0, 'y': 8, 'demand': 8}], 'depot': 0, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 471.6513598593217, 'objective': 471.6513598593217}","[[0, 2, 8, 10, 9, 3, 7, 0], [0, 1, 6, 5, 4, 0]]",30,csv,0
CVRP,CVRP,"There’s a bottling plant that fills trucks and sends them out to a list of bars, and the goal is to plan the runs so every bar gets served exactly once and each driver returns to the plant at the end of the day. The decisions are about grouping nearby bars into routes without overstuffing any truck — each route can only carry so much product. Better plans are the ones that reduce overall driving: compute the sum of the distances of all routes and aim for the smallest possible total. The concrete details are shown below.
{
""total_locations_including_plant"": 13,
""nodes"": [
{
""location_id"": 1,
""map_x_coordinate"": 84,
""map_y_coordinate"": 77,
""bar_demand_units"": 0
},
{
""location_id"": 2,
""map_x_coordinate"": 91,
""map_y_coordinate"": 68,
""bar_demand_units"": 10
},
{
""location_id"": 3,
""map_x_coordinate"": 0,
""map_y_coordinate"": 0,
""bar_demand_units"": 16
},
{
""location_id"": 4,
""map_x_coordinate"": 11,
""map_y_coordinate"": 19,
""bar_demand_units"": 23
},
{
""location_id"": 5,
""map_x_coordinate"": 13,
""map_y_coordinate"": 26,
""bar_demand_units"": 2
},
{
""location_id"": 6,
""map_x_coordinate"": 11,
""map_y_coordinate"": 15,
""bar_demand_units"": 3
},
{
""location_id"": 7,
""map_x_coordinate"": 80,
""map_y_coordinate"": 40,
""bar_demand_units"": 2
},
{
""location_id"": 8,
""map_x_coordinate"": 100,
""map_y_coordinate"": 74,
""bar_demand_units"": 7
},
{
""location_id"": 9,
""map_x_coordinate"": 92,
""map_y_coordinate"": 100,
""bar_demand_units"": 12
},
{
""location_id"": 10,
""map_x_coordinate"": 80,
""map_y_coordinate"": 45,
""bar_demand_units"": 23
},
{
""location_id"": 11,
""map_x_coordinate"": 15,
""map_y_coordinate"": 21,
""bar_demand_units"": 20
},
{
""location_id"": 12,
""map_x_coordinate"": 92,
""map_y_coordinate"": 87,
""bar_demand_units"": 24
},
{
""location_id"": 13,
""map_x_coordinate"": 77,
""map_y_coordinate"": 49,
""bar_demand_units"": 3
}
],
""plant_location_id"": 1,
""truck_capacity_units"": 100
}
Oh, and one more thing — when you give the routes back, please use this simple JSON layout so it's easy to read and check:
{
""solution"": [[plant_id, bar_id, ... , plant_id], [plant_id, bar_id, ... , plant_id], ...]
}
Think of it like a little form: ""solution"" is a list of routes, each route is the sequence of stops starting and ending at the plant (plant_id) with the bars (bar_id) visited in order. The ""..."" just means there can be more stops in between. This is only a sketch of the shape I expect, not the actual routes.
Please use the exact identifiers from the instance input — don't rename them or invent new ones.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[84, 77], [91, 68], [0, 0], [11, 19], [13, 26], [11, 15], [80, 40], [100, 74], [92, 100], [80, 45], [15, 21], [92, 87], [77, 49]], 'depot': 0, 'demands': [0, 10, 16, 23, 2, 3, 2, 7, 12, 23, 20, 24, 3], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 323.0157049068739, 'objective': 323.0157049068739}","[[0, 4, 10, 3, 5, 2, 6, 9, 12, 0], [0, 8, 11, 7, 1, 0]]",323.0157049068739,"{'problem_type': 'CVRP', 'num_nodes': 13, 'nodes': [{'id': 1, 'x': 84, 'y': 77, 'demand': 0}, {'id': 2, 'x': 91, 'y': 68, 'demand': 10}, {'id': 3, 'x': 0, 'y': 0, 'demand': 16}, {'id': 4, 'x': 11, 'y': 19, 'demand': 23}, {'id': 5, 'x': 13, 'y': 26, 'demand': 2}, {'id': 6, 'x': 11, 'y': 15, 'demand': 3}, {'id': 7, 'x': 80, 'y': 40, 'demand': 2}, {'id': 8, 'x': 100, 'y': 74, 'demand': 7}, {'id': 9, 'x': 92, 'y': 100, 'demand': 12}, {'id': 10, 'x': 80, 'y': 45, 'demand': 23}, {'id': 11, 'x': 15, 'y': 21, 'demand': 20}, {'id': 12, 'x': 92, 'y': 87, 'demand': 24}, {'id': 13, 'x': 77, 'y': 49, 'demand': 3}], 'depot': 1, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 323.0157049068739, 'objective': 323.0157049068739}","[[1, 5, 11, 4, 6, 3, 7, 10, 13, 1], [1, 9, 12, 8, 2, 1]]",31,json,1
CVRP,CVRP,"I help organize the creamery’s pickup runs: there’s a set of farms that need milk picked up, and the job is to group them into truck trips so every farm gets visited exactly once. Each truck leaves the creamery, visits the farms on its list, and then returns to the creamery, and no trip can carry more milk than the tanker holds. A better plan is one that cuts down on total driving — measured by adding up the miles for every trip — so the goal is to pick routes that keep that total as small as possible. Concrete details are shown below.
{
""total_locations"": 11,
""nodes"": [
{
""location_id"": 0,
""x_coordinate"": 70,
""y_coordinate"": 48,
""milk_amount"": 0
},
{
""location_id"": 1,
""x_coordinate"": 79,
""y_coordinate"": 67,
""milk_amount"": 5
},
{
""location_id"": 2,
""x_coordinate"": 3,
""y_coordinate"": 49,
""milk_amount"": 7
},
{
""location_id"": 3,
""x_coordinate"": 55,
""y_coordinate"": 30,
""milk_amount"": 5
},
{
""location_id"": 4,
""x_coordinate"": 85,
""y_coordinate"": 14,
""milk_amount"": 7
},
{
""location_id"": 5,
""x_coordinate"": 100,
""y_coordinate"": 69,
""milk_amount"": 8
},
{
""location_id"": 6,
""x_coordinate"": 90,
""y_coordinate"": 8,
""milk_amount"": 6
},
{
""location_id"": 7,
""x_coordinate"": 47,
""y_coordinate"": 86,
""milk_amount"": 5
},
{
""location_id"": 8,
""x_coordinate"": 42,
""y_coordinate"": 67,
""milk_amount"": 5
},
{
""location_id"": 9,
""x_coordinate"": 0,
""y_coordinate"": 0,
""milk_amount"": 6
},
{
""location_id"": 10,
""x_coordinate"": 55,
""y_coordinate"": 100,
""milk_amount"": 6
}
],
""creamery_id"": 0,
""tanker_capacity"": 66
}
When you’re ready to send me a plan, just put it in this simple JSON layout so I can read the routes cleanly:
{
""solution"": [[creamery_id, farm_id, ... , creamery_id], [creamery_id, farm_id, ... , creamery_id], ...]
}
This is just a quick sketch of the shape I’m expecting: ""solution"" is a list of routes, each route is a list that starts and ends at the creamery and lists the farms visited in between. Think of it like filling out a little itinerary form for each truck.
This JSON is only an outline of the format — not the actual routes. Please use the exact identifiers from the instance input when you fill it in: don’t rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[70, 48], [79, 67], [3, 49], [55, 30], [85, 14], [100, 69], [90, 8], [47, 86], [42, 67], [0, 0], [55, 100]], 'depot': 0, 'demands': [0, 5, 7, 5, 7, 8, 6, 5, 5, 6, 6], 'capacity': 66, 'num_vehicles': 1, 'total_distance': 373.5416674218914, 'objective': 373.5416674218914}","[[0, 1, 5, 10, 7, 8, 2, 9, 3, 6, 4, 0]]",373.5416674218914,"{'problem_type': 'CVRP', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 70, 'y': 48, 'demand': 0}, {'id': 1, 'x': 79, 'y': 67, 'demand': 5}, {'id': 2, 'x': 3, 'y': 49, 'demand': 7}, {'id': 3, 'x': 55, 'y': 30, 'demand': 5}, {'id': 4, 'x': 85, 'y': 14, 'demand': 7}, {'id': 5, 'x': 100, 'y': 69, 'demand': 8}, {'id': 6, 'x': 90, 'y': 8, 'demand': 6}, {'id': 7, 'x': 47, 'y': 86, 'demand': 5}, {'id': 8, 'x': 42, 'y': 67, 'demand': 5}, {'id': 9, 'x': 0, 'y': 0, 'demand': 6}, {'id': 10, 'x': 55, 'y': 100, 'demand': 6}], 'depot': 0, 'capacity': 66, 'num_vehicles': 1, 'total_distance': 373.5416674218914, 'objective': 373.5416674218914}","[[0, 1, 5, 10, 7, 8, 2, 9, 3, 6, 4, 0]]",32,json,0
CVRP,CVRP,"Recently the office asked for a simpler way to send crews out: every technician should start and finish at the central hub, visit each service location only once, and only carry what fits in their van. The trick is picking which stops go on each technician’s run and the order they’ll be visited, while never exceeding any van’s load and never leaving a site unvisited or visited twice. The scoring is straightforward — total miles driven by the whole team, calculated by adding up each route’s distance — and the exact instance details follow below.
Instance details: 12 locations (including central hub 1); van capacity 408.
| location_id | x_coord | y_coord | service_demand |
|---|---|---|---|
| 1 | 54 | 34 | 0 |
| 2 | 96 | 2 | 33 |
| 3 | 19 | 100 | 17 |
| 4 | 65 | 96 | 92 |
| 5 | 0 | 25 | 77 |
| 6 | 6 | 64 | 45 |
| 7 | 6 | 98 | 17 |
| 8 | 27 | 95 | 48 |
| 9 | 81 | 0 | 32 |
| 10 | 37 | 54 | 32 |
| 11 | 39 | 41 | 11 |
| 12 | 100 | 94 | 98 |
Every location is listed once so technician routes can be formed without exceeding van capacity and total miles can be computed.
Also, when you send the route plan back, just stick to this simple JSON layout so it's easy to read and check:
{
""solution"": [[hub_id, site_id, ... , hub_id], [hub_id, site_id, ... , hub_id], ...]
}
Think of it like a little form: the outer list is the whole day's set of runs, each inner list is one technician's trip that starts and ends at the hub and lists the service sites in visit order. This block is just a sketch of the shape I want — fill it with the actual route lists for the instance.
Please use the exact identifiers from the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”"".","{'coordinates': [[54, 34], [96, 2], [19, 100], [65, 96], [0, 25], [6, 64], [6, 98], [27, 95], [81, 0], [37, 54], [39, 41], [100, 94]], 'depot': 0, 'demands': [0, 33, 17, 92, 77, 45, 17, 48, 32, 32, 11, 98], 'capacity': 408, 'num_vehicles': 2, 'total_distance': 465.07505302496656, 'objective': 465.07505302496656}","[[0, 9, 4, 0], [0, 10, 5, 6, 2, 7, 3, 11, 1, 8, 0]]",465.07505302496656,"{'problem_type': 'CVRP', 'num_nodes': 12, 'nodes': [{'id': 1, 'x': 54, 'y': 34, 'demand': 0}, {'id': 2, 'x': 96, 'y': 2, 'demand': 33}, {'id': 3, 'x': 19, 'y': 100, 'demand': 17}, {'id': 4, 'x': 65, 'y': 96, 'demand': 92}, {'id': 5, 'x': 0, 'y': 25, 'demand': 77}, {'id': 6, 'x': 6, 'y': 64, 'demand': 45}, {'id': 7, 'x': 6, 'y': 98, 'demand': 17}, {'id': 8, 'x': 27, 'y': 95, 'demand': 48}, {'id': 9, 'x': 81, 'y': 0, 'demand': 32}, {'id': 10, 'x': 37, 'y': 54, 'demand': 32}, {'id': 11, 'x': 39, 'y': 41, 'demand': 11}, {'id': 12, 'x': 100, 'y': 94, 'demand': 98}], 'depot': 1, 'capacity': 408, 'num_vehicles': 2, 'total_distance': 465.07505302496656, 'objective': 465.07505302496656}","[[1, 10, 5, 1], [1, 11, 6, 7, 3, 8, 4, 12, 2, 9, 1]]",33,markdown_table,1
CVRP,CVRP,"Picture this: a fleet of vans leaves and returns to the same downtown hub, and the challenge is to bundle customer stops into those loops so everyone gets one delivery, no one gets served twice, and each loop only carries as many parcels as the van can handle. The plan that’s preferred is the one with the least total mileage — just sum the lengths of all the loops and aim for the smallest number. The concrete numbers and locations follow below.
There are 14 locations including the downtown hub A, and each van can carry up to 100 parcels.
Location A at coordinates (86, 21) requires 0 parcels.
Location B at coordinates (3, 52) requires 23 parcels.
Location C at coordinates (67, 37) requires 5 parcels.
Location D at coordinates (62, 13) requires 18 parcels.
Location E at coordinates (33, 0) requires 20 parcels.
Location F at coordinates (24, 100) requires 2 parcels.
Location G at coordinates (63, 59) requires 26 parcels.
Location H at coordinates (87, 38) requires 17 parcels.
Location I at coordinates (66, 34) requires 8 parcels.
Location J at coordinates (18, 88) requires 12 parcels.
Location K at coordinates (0, 87) requires 9 parcels.
Location L at coordinates (40, 62) requires 20 parcels.
Location M at coordinates (100, 81) requires 8 parcels.
Location N at coordinates (15, 36) requires 8 parcels.
Use these lines to assemble loops that start and end at A while respecting the 100-parcel limit.
Oh, and when you send the route plan back, just use this simple JSON shape:
{
""solution"": [[depot_id, location_id, ... , depot_id], [depot_id, location_id, ... , depot_id], ...]
}
Here ""solution"" is a list of routes; each route is a loop that starts and ends at the depot_id, and the location_id entries in between are the stops in visit order. Think of it like filling out a little route form — it's only a sketch of the shape I need, not the actual routes for this instance.
Please make sure to use the exact identifiers that appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[86, 21], [3, 52], [67, 37], [62, 13], [33, 0], [24, 100], [63, 59], [87, 38], [66, 34], [18, 88], [0, 87], [40, 62], [100, 81], [15, 36]], 'depot': 0, 'demands': [0, 23, 5, 18, 20, 2, 26, 17, 8, 12, 9, 20, 8, 8], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 459.77852485652346, 'objective': 459.77852485652346}","[[0, 7, 6, 11, 2, 8, 0], [0, 12, 5, 9, 10, 1, 13, 4, 3, 0]]",459.77852485652346,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 86, 'y': 21, 'demand': 0}, {'id': 'B', 'x': 3, 'y': 52, 'demand': 23}, {'id': 'C', 'x': 67, 'y': 37, 'demand': 5}, {'id': 'D', 'x': 62, 'y': 13, 'demand': 18}, {'id': 'E', 'x': 33, 'y': 0, 'demand': 20}, {'id': 'F', 'x': 24, 'y': 100, 'demand': 2}, {'id': 'G', 'x': 63, 'y': 59, 'demand': 26}, {'id': 'H', 'x': 87, 'y': 38, 'demand': 17}, {'id': 'I', 'x': 66, 'y': 34, 'demand': 8}, {'id': 'J', 'x': 18, 'y': 88, 'demand': 12}, {'id': 'K', 'x': 0, 'y': 87, 'demand': 9}, {'id': 'L', 'x': 40, 'y': 62, 'demand': 20}, {'id': 'M', 'x': 100, 'y': 81, 'demand': 8}, {'id': 'N', 'x': 15, 'y': 36, 'demand': 8}], 'depot': 'A', 'capacity': 100, 'num_vehicles': 2, 'total_distance': 459.77852485652346, 'objective': 459.77852485652346}","[['A', 'H', 'G', 'L', 'C', 'I', 'A'], ['A', 'M', 'F', 'J', 'K', 'B', 'N', 'E', 'D', 'A']]",34,nl,names
CVRP,CVRP,"Many teachers asked for deliveries, so the logistics team is setting up a handful of runs from the main store where each route departs from and returns to the store and stops at each classroom exactly once. The practical choice is grouping stops per run so each vehicle stays under its load limit, and the goal is to keep the combined driving distance — just the total of all the trip distances — as low as possible. Concrete details are provided below.
The logistics team will plan routes for 12 locations, with the central store at 1 and a vehicle capacity of 3.
| location_id | x_coordinate | y_coordinate | supply_demand |
|---|---|---|---|
| 1 | 0 | 0 | 0 |
| 2 | 74 | 37 | 1 |
| 3 | 73 | 98 | 1 |
| 4 | 100 | 37 | 1 |
| 5 | 75 | 49 | 1 |
| 6 | 22 | 99 | 1 |
| 7 | 34 | 36 | 1 |
| 8 | 11 | 100 | 1 |
| 9 | 79 | 98 | 1 |
| 10 | 97 | 51 | 1 |
| 11 | 28 | 82 | 1 |
| 12 | 61 | 39 | 1 |
These details let the logistics team form feasible routes from 1 for 12 locations under capacity 3.
Oh, and one quick thing — when you send back the set of runs, please use this simple JSON layout so it's easy to read and parse:
{
""solution"": [[store_id, classroom_id, ... , store_id], [store_id, classroom_id, ... , store_id], ...]
}
This just shows the shape I need: ""solution"" is a list of routes, each route is a list that starts and ends with the store and has the classrooms visited in order. Think of it like filling out a short form for each run. It's just a sketch of the format, not the actual routes.
Please use the exact identifiers from the instance input — no renaming and no new labels.
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[0, 0], [74, 37], [73, 98], [100, 37], [75, 49], [22, 99], [34, 36], [11, 100], [79, 98], [97, 51], [28, 82], [61, 39]], 'depot': 0, 'demands': [0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 'capacity': 3, 'num_vehicles': 4, 'total_distance': 862.9657684694623, 'objective': 862.9657684694623}","[[0, 10, 5, 7, 0], [0, 6, 11, 0], [0, 3, 9, 1, 0], [0, 4, 8, 2, 0]]",862.9657684694623,"{'problem_type': 'CVRP', 'num_nodes': 12, 'nodes': [{'id': 1, 'x': 0, 'y': 0, 'demand': 0}, {'id': 2, 'x': 74, 'y': 37, 'demand': 1}, {'id': 3, 'x': 73, 'y': 98, 'demand': 1}, {'id': 4, 'x': 100, 'y': 37, 'demand': 1}, {'id': 5, 'x': 75, 'y': 49, 'demand': 1}, {'id': 6, 'x': 22, 'y': 99, 'demand': 1}, {'id': 7, 'x': 34, 'y': 36, 'demand': 1}, {'id': 8, 'x': 11, 'y': 100, 'demand': 1}, {'id': 9, 'x': 79, 'y': 98, 'demand': 1}, {'id': 10, 'x': 97, 'y': 51, 'demand': 1}, {'id': 11, 'x': 28, 'y': 82, 'demand': 1}, {'id': 12, 'x': 61, 'y': 39, 'demand': 1}], 'depot': 1, 'capacity': 3, 'num_vehicles': 4, 'total_distance': 862.9657684694623, 'objective': 862.9657684694623}","[[1, 11, 6, 8, 1], [1, 7, 12, 1], [1, 4, 10, 2, 1], [1, 5, 9, 3, 1]]",35,markdown_table,1
CVRP,CVRP,"We have a dry-cleaning shop that needs a few pickup routes: each route starts at the shop, goes to several customers, and returns to the shop when done. Every address needs a single pickup (no skipping or double-picking), and the bags collected on any route must fit inside the van. The idea is to arrange the stops so the total driving distance — the sum of all the round-trip miles for every route — is as small as possible. Concrete details like customer addresses, bag counts, and the van limit are shown below.
{
""total_locations_including_shop"": 13,
""nodes"": [
{
""location_id"": 1,
""x_coordinate"": 31,
""y_coordinate"": 55,
""bags_needed_pickup"": 0
},
{
""location_id"": 2,
""x_coordinate"": 1,
""y_coordinate"": 3,
""bags_needed_pickup"": 12
},
{
""location_id"": 3,
""x_coordinate"": 38,
""y_coordinate"": 45,
""bags_needed_pickup"": 10
},
{
""location_id"": 4,
""x_coordinate"": 6,
""y_coordinate"": 27,
""bags_needed_pickup"": 7
},
{
""location_id"": 5,
""x_coordinate"": 66,
""y_coordinate"": 53,
""bags_needed_pickup"": 21
},
{
""location_id"": 6,
""x_coordinate"": 48,
""y_coordinate"": 100,
""bags_needed_pickup"": 10
},
{
""location_id"": 7,
""x_coordinate"": 87,
""y_coordinate"": 82,
""bags_needed_pickup"": 19
},
{
""location_id"": 8,
""x_coordinate"": 2,
""y_coordinate"": 42,
""bags_needed_pickup"": 19
},
{
""location_id"": 9,
""x_coordinate"": 12,
""y_coordinate"": 24,
""bags_needed_pickup"": 12
},
{
""location_id"": 10,
""x_coordinate"": 92,
""y_coordinate"": 0,
""bags_needed_pickup"": 25
},
{
""location_id"": 11,
""x_coordinate"": 0,
""y_coordinate"": 53,
""bags_needed_pickup"": 14
},
{
""location_id"": 12,
""x_coordinate"": 100,
""y_coordinate"": 71,
""bags_needed_pickup"": 10
},
{
""location_id"": 13,
""x_coordinate"": 76,
""y_coordinate"": 62,
""bags_needed_pickup"": 5
}
],
""shop_node_id"": 1,
""van_capacity_bags"": 100
}
Also, when you send the actual routes back, please use this little JSON layout so I can read it easily:
{
""solution"": [[shop_id, customer_id, ... , shop_id], [shop_id, customer_id, ... , shop_id], ...]
}
Think of ""solution"" as a list of routes. Each inner list is one round-trip that starts and ends at the shop (shop_id) and lists the customers visited (customer_id) in order. This block is just a sketch of the shape I expect, not the actual answer.
Please make sure to use the exact identifiers from the instance input — no renaming, no extra labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[31, 55], [1, 3], [38, 45], [6, 27], [66, 53], [48, 100], [87, 82], [2, 42], [12, 24], [92, 0], [0, 53], [100, 71], [76, 62]], 'depot': 0, 'demands': [0, 12, 10, 7, 21, 10, 19, 19, 12, 25, 14, 10, 5], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 431.05535216317463, 'objective': 431.05535216317463}","[[0, 10, 7, 3, 1, 8, 0], [0, 2, 9, 4, 12, 11, 6, 5, 0]]",431.05535216317463,"{'problem_type': 'CVRP', 'num_nodes': 13, 'nodes': [{'id': 1, 'x': 31, 'y': 55, 'demand': 0}, {'id': 2, 'x': 1, 'y': 3, 'demand': 12}, {'id': 3, 'x': 38, 'y': 45, 'demand': 10}, {'id': 4, 'x': 6, 'y': 27, 'demand': 7}, {'id': 5, 'x': 66, 'y': 53, 'demand': 21}, {'id': 6, 'x': 48, 'y': 100, 'demand': 10}, {'id': 7, 'x': 87, 'y': 82, 'demand': 19}, {'id': 8, 'x': 2, 'y': 42, 'demand': 19}, {'id': 9, 'x': 12, 'y': 24, 'demand': 12}, {'id': 10, 'x': 92, 'y': 0, 'demand': 25}, {'id': 11, 'x': 0, 'y': 53, 'demand': 14}, {'id': 12, 'x': 100, 'y': 71, 'demand': 10}, {'id': 13, 'x': 76, 'y': 62, 'demand': 5}], 'depot': 1, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 431.05535216317463, 'objective': 431.05535216317463}","[[1, 11, 8, 4, 2, 9, 1], [1, 3, 10, 5, 13, 12, 7, 6, 1]]",36,json,1
CVRP,CVRP,"We need to sort out routes from the farm yard so the spreader trucks leave the yard, visit a bunch of fields (each field just once), and return to the yard without overfilling any spreader. The decision is which fields to group on each outing and the order to visit them, with the trade-off being keeping every trip within load limits while driving as few miles as possible. To compare plans, simply total the miles for every trip — the lower that sum, the better the plan. The concrete list of fields, their fertilizer needs, and the spreader capacity will be shown below.
{
""total_locations_count"": 12,
""nodes"": [
{
""location_node_id"": 0,
""x_coordinate"": 0,
""y_coordinate"": 55,
""fertilizer_demand"": 0
},
{
""location_node_id"": 1,
""x_coordinate"": 55,
""y_coordinate"": 96,
""fertilizer_demand"": 75
},
{
""location_node_id"": 2,
""x_coordinate"": 17,
""y_coordinate"": 100,
""fertilizer_demand"": 93
},
{
""location_node_id"": 3,
""x_coordinate"": 64,
""y_coordinate"": 2,
""fertilizer_demand"": 90
},
{
""location_node_id"": 4,
""x_coordinate"": 15,
""y_coordinate"": 81,
""fertilizer_demand"": 51
},
{
""location_node_id"": 5,
""x_coordinate"": 0,
""y_coordinate"": 40,
""fertilizer_demand"": 84
},
{
""location_node_id"": 6,
""x_coordinate"": 1,
""y_coordinate"": 45,
""fertilizer_demand"": 86
},
{
""location_node_id"": 7,
""x_coordinate"": 62,
""y_coordinate"": 27,
""fertilizer_demand"": 80
},
{
""location_node_id"": 8,
""x_coordinate"": 100,
""y_coordinate"": 26,
""fertilizer_demand"": 62
},
{
""location_node_id"": 9,
""x_coordinate"": 24,
""y_coordinate"": 85,
""fertilizer_demand"": 79
},
{
""location_node_id"": 10,
""x_coordinate"": 45,
""y_coordinate"": 91,
""fertilizer_demand"": 69
},
{
""location_node_id"": 11,
""x_coordinate"": 48,
""y_coordinate"": 0,
""fertilizer_demand"": 56
}
],
""farm_yard_node"": 0,
""spreader_capacity"": 564
}
Also, when you send the plan back, just put the routes into a little JSON object like this:
{
""solution"": [[""yard_id"", ""field_id"", ..., ""yard_id""], [""yard_id"", ""field_id"", ..., ""yard_id""], ...]
}
This just shows the shape I want: ""solution"" is a list of trips, and each trip is an ordered list that starts and ends at the yard and lists the fields visited in between. Treat the placeholders as examples — you'll replace them with the real IDs from the instance when you give the actual plan. The JSON above is only a sketch of the shape I expect, not the final answer.
Please be careful to use the exact identifiers from the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 55], [55, 96], [17, 100], [64, 2], [15, 81], [0, 40], [1, 45], [62, 27], [100, 26], [24, 85], [45, 91], [48, 0]], 'depot': 0, 'demands': [0, 75, 93, 90, 51, 84, 86, 80, 62, 79, 69, 56], 'capacity': 564, 'num_vehicles': 2, 'total_distance': 401.83558091158136, 'objective': 401.83558091158136}","[[0, 6, 5, 11, 3, 8, 7, 0], [0, 9, 10, 1, 2, 4, 0]]",401.83558091158136,"{'problem_type': 'CVRP', 'num_nodes': 12, 'nodes': [{'id': 0, 'x': 0, 'y': 55, 'demand': 0}, {'id': 1, 'x': 55, 'y': 96, 'demand': 75}, {'id': 2, 'x': 17, 'y': 100, 'demand': 93}, {'id': 3, 'x': 64, 'y': 2, 'demand': 90}, {'id': 4, 'x': 15, 'y': 81, 'demand': 51}, {'id': 5, 'x': 0, 'y': 40, 'demand': 84}, {'id': 6, 'x': 1, 'y': 45, 'demand': 86}, {'id': 7, 'x': 62, 'y': 27, 'demand': 80}, {'id': 8, 'x': 100, 'y': 26, 'demand': 62}, {'id': 9, 'x': 24, 'y': 85, 'demand': 79}, {'id': 10, 'x': 45, 'y': 91, 'demand': 69}, {'id': 11, 'x': 48, 'y': 0, 'demand': 56}], 'depot': 0, 'capacity': 564, 'num_vehicles': 2, 'total_distance': 401.83558091158136, 'objective': 401.83558091158136}","[[0, 6, 5, 11, 3, 8, 7, 0], [0, 9, 10, 1, 2, 4, 0]]",37,json,0
CVRP,CVRP,"On a busy morning the mobile grooming van has to be scheduled so each customer gets visited once and the van always goes out from and back to the shop, with each outing carrying only as much equipment as the van can hold. The decision is which customers to put together on each trip and in what sequence. The best-looking schedule is the one with the fewest total miles driven — just total the distance of every route to see that — and the detailed stops and supply needs appear below.
There are 11 locations including the groomer’s base A, and the van's equipment capacity is 39 units.
Location A at coordinates (0, 0) requires 0 equipment units.
Location B at coordinates (6, 96) requires 9 equipment units.
Location C at coordinates (98, 39) requires 2 equipment units.
Location D at coordinates (10, 85) requires 5 equipment units.
Location E at coordinates (100, 68) requires 6 equipment units.
Location F at coordinates (76, 16) requires 3 equipment units.
Location G at coordinates (4, 48) requires 2 equipment units.
Location H at coordinates (99, 100) requires 2 equipment units.
Location I at coordinates (55, 73) requires 2 equipment units.
Location J at coordinates (57, 79) requires 9 equipment units.
Location K at coordinates (87, 57) requires 9 equipment units.
Each route must start and end at A and keep the total required equipment per outing at or below 39 units.
And just so we're on the same page about how I'd like the final reply formatted, please follow this simple JSON shape when you give the routes — nothing fancy, just a list of routes where each route is a list of stops that starts and ends at the shop.
{
""solution"": [[""shop_id"", ""customer_id"", ... , ""shop_id""], [""shop_id"", ""customer_id"", ... , ""shop_id""], ...]
}
Think of ""solution"" as the whole schedule, each inner list as one trip the van takes (first item is the shop, then the customers in visit order, then back to the shop). This is just a sketch of the expected shape, not the actual answer.
Please make sure to use the exact identifiers from the instance input — don't rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 0], [6, 96], [98, 39], [10, 85], [100, 68], [76, 16], [4, 48], [99, 100], [55, 73], [57, 79], [87, 57]], 'depot': 0, 'demands': [0, 9, 2, 5, 6, 3, 2, 2, 2, 9, 9], 'capacity': 39, 'num_vehicles': 2, 'total_distance': 517.8575697154001, 'objective': 517.8575697154001}","[[0, 1, 3, 6, 0], [0, 8, 9, 7, 4, 10, 2, 5, 0]]",517.8575697154001,"{'problem_type': 'CVRP', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 0, 'y': 0, 'demand': 0}, {'id': 'B', 'x': 6, 'y': 96, 'demand': 9}, {'id': 'C', 'x': 98, 'y': 39, 'demand': 2}, {'id': 'D', 'x': 10, 'y': 85, 'demand': 5}, {'id': 'E', 'x': 100, 'y': 68, 'demand': 6}, {'id': 'F', 'x': 76, 'y': 16, 'demand': 3}, {'id': 'G', 'x': 4, 'y': 48, 'demand': 2}, {'id': 'H', 'x': 99, 'y': 100, 'demand': 2}, {'id': 'I', 'x': 55, 'y': 73, 'demand': 2}, {'id': 'J', 'x': 57, 'y': 79, 'demand': 9}, {'id': 'K', 'x': 87, 'y': 57, 'demand': 9}], 'depot': 'A', 'capacity': 39, 'num_vehicles': 2, 'total_distance': 517.8575697154001, 'objective': 517.8575697154001}","[['A', 'B', 'D', 'G', 'A'], ['A', 'I', 'J', 'H', 'E', 'K', 'C', 'F', 'A']]",38,nl,names
CVRP,CVRP,"Someone has to schedule the refill deliveries so every department is visited one time, each route starts and ends at the central office, and no single trip carries more than the truck’s capacity. The decision is about which departments to group together on each run to make the total distance as small as possible — the total distance is just the sum of all individual trip distances. Details for the specific case are shown below.
For this instance there are 15 locations in total, the central office is A, and the truck's capacity is 100.
Location A at (52, 61) has demand 0.
Location B at (80, 71) has demand 16.
Location C at (26, 100) has demand 29.
Location D at (93, 51) has demand 12.
Location E at (93, 78) has demand 15.
Location F at (100, 8) has demand 22.
Location G at (59, 6) has demand 28.
Location H at (54, 73) has demand 18.
Location I at (80, 49) has demand 17.
Location J at (26, 39) has demand 27.
Location K at (78, 0) has demand 12.
Location L at (7, 18) has demand 18.
Location M at (72, 65) has demand 27.
Location N at (70, 10) has demand 19.
Location O at (0, 57) has demand 5.
Assign every department exactly once so each route starts and ends at A and no route's total demand exceeds 100.
Oh, and one more thing — when you give the planned trips back, please follow this simple JSON layout so it's easy to read and use:
{
""solution"": [[central_office_id, department_id, ... , central_office_id], [central_office_id, department_id, ... , central_office_id], ...]
}
Think of each inner list as one run for the truck: it starts at the central office, lists the departments visited in order, and ends back at the central office. This is just a sketch of the shape I need, not the actual set of stops.
Please make sure to use the exact identifiers from the problem input — don't rename them or invent new ones.
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[52, 61], [80, 71], [26, 100], [93, 51], [93, 78], [100, 8], [59, 6], [54, 73], [80, 49], [26, 39], [78, 0], [7, 18], [72, 65], [70, 10], [0, 57]], 'depot': 0, 'demands': [0, 16, 29, 12, 15, 22, 28, 18, 17, 27, 12, 18, 27, 19, 5], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 493.9600044534037, 'objective': 493.9600044534037}","[[0, 6, 13, 10, 5, 0], [0, 7, 2, 14, 11, 9, 0], [0, 8, 3, 4, 1, 12, 0]]",493.9600044534037,"{'problem_type': 'CVRP', 'num_nodes': 15, 'nodes': [{'id': 'A', 'x': 52, 'y': 61, 'demand': 0}, {'id': 'B', 'x': 80, 'y': 71, 'demand': 16}, {'id': 'C', 'x': 26, 'y': 100, 'demand': 29}, {'id': 'D', 'x': 93, 'y': 51, 'demand': 12}, {'id': 'E', 'x': 93, 'y': 78, 'demand': 15}, {'id': 'F', 'x': 100, 'y': 8, 'demand': 22}, {'id': 'G', 'x': 59, 'y': 6, 'demand': 28}, {'id': 'H', 'x': 54, 'y': 73, 'demand': 18}, {'id': 'I', 'x': 80, 'y': 49, 'demand': 17}, {'id': 'J', 'x': 26, 'y': 39, 'demand': 27}, {'id': 'K', 'x': 78, 'y': 0, 'demand': 12}, {'id': 'L', 'x': 7, 'y': 18, 'demand': 18}, {'id': 'M', 'x': 72, 'y': 65, 'demand': 27}, {'id': 'N', 'x': 70, 'y': 10, 'demand': 19}, {'id': 'O', 'x': 0, 'y': 57, 'demand': 5}], 'depot': 'A', 'capacity': 100, 'num_vehicles': 3, 'total_distance': 493.9600044534037, 'objective': 493.9600044534037}","[['A', 'G', 'N', 'K', 'F', 'A'], ['A', 'H', 'C', 'O', 'L', 'J', 'A'], ['A', 'I', 'D', 'E', 'B', 'M', 'A']]",39,nl,names
CVRP,CVRP,"Recently the town asked for a cleaner schedule of tanker runs to top up community water points. The task is to pick which taps go together on each roundtrip out of the municipal yard so that each tap is served exactly once, each trip stays within the tanker’s carrying limit, and the total amount of driving across all trips is as small as it can be. To compare options, simply total the distance driven on every trip — the one with the lowest total is preferred. Concrete details about stops, demand amounts, and tanker capacity follow below.
There are 14 locations in this instance, the municipal yard is node A, and each tanker can carry up to 110 units.
Location A at (0, 0) requires 0 units of water.
Location B at (94, 99) requires 5 units of water.
Location C at (26, 35) requires 5 units of water.
Location D at (74, 52) requires 7 units of water.
Location E at (58, 59) requires 9 units of water.
Location F at (57, 33) requires 7 units of water.
Location G at (97, 100) requires 8 units of water.
Location H at (51, 66) requires 5 units of water.
Location I at (46, 31) requires 8 units of water.
Location J at (46, 26) requires 8 units of water.
Location K at (100, 98) requires 9 units of water.
Location L at (3, 12) requires 6 units of water.
Location M at (66, 51) requires 7 units of water.
Location N at (44, 47) requires 8 units of water.
Use these details to form roundtrips that start and end at A, visit every location once, and never exceed the tanker capacity of 110.
When you send back the proposed rounds, just stick to a simple JSON shape like this:
{
""solution"": [[yard_id, tap_id, ... , yard_id], [yard_id, tap_id, ... , yard_id], ...]
}
This little sketch means: ""solution"" is a list of trips, each trip is an ordered list of stop identifiers that starts and ends at the municipal yard. The placeholders here (yard_id, tap_id) just show the shape — replace them with the actual stop IDs from the instance. This is only an example of the format, not the actual plan.
Please make sure to use the exact identifiers given in the instance input — do not rename them or invent new ones.
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[0, 0], [94, 99], [26, 35], [74, 52], [58, 59], [57, 33], [97, 100], [51, 66], [46, 31], [46, 26], [100, 98], [3, 12], [66, 51], [44, 47]], 'depot': 0, 'demands': [0, 5, 5, 7, 9, 7, 8, 5, 8, 8, 9, 6, 7, 8], 'capacity': 110, 'num_vehicles': 1, 'total_distance': 305.8852381247973, 'objective': 305.8852381247973}","[[0, 9, 8, 5, 12, 3, 10, 6, 1, 7, 4, 13, 2, 11, 0]]",305.8852381247973,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 0, 'y': 0, 'demand': 0}, {'id': 'B', 'x': 94, 'y': 99, 'demand': 5}, {'id': 'C', 'x': 26, 'y': 35, 'demand': 5}, {'id': 'D', 'x': 74, 'y': 52, 'demand': 7}, {'id': 'E', 'x': 58, 'y': 59, 'demand': 9}, {'id': 'F', 'x': 57, 'y': 33, 'demand': 7}, {'id': 'G', 'x': 97, 'y': 100, 'demand': 8}, {'id': 'H', 'x': 51, 'y': 66, 'demand': 5}, {'id': 'I', 'x': 46, 'y': 31, 'demand': 8}, {'id': 'J', 'x': 46, 'y': 26, 'demand': 8}, {'id': 'K', 'x': 100, 'y': 98, 'demand': 9}, {'id': 'L', 'x': 3, 'y': 12, 'demand': 6}, {'id': 'M', 'x': 66, 'y': 51, 'demand': 7}, {'id': 'N', 'x': 44, 'y': 47, 'demand': 8}], 'depot': 'A', 'capacity': 110, 'num_vehicles': 1, 'total_distance': 305.8852381247973, 'objective': 305.8852381247973}","[['A', 'J', 'I', 'F', 'M', 'D', 'K', 'G', 'B', 'H', 'E', 'N', 'C', 'L', 'A']]",40,nl,names
CVRP,CVRP,"Recently the dispatchers had to put together a set of patrol runs: vans leaving and returning to the same garage, each one equipped for certain calls. They need to decide who goes where so every reported vehicle gets serviced exactly once, no van’s equipment load exceeds what it can hold, and the whole day has the fewest miles possible — compute that by summing every route’s distance and choosing the smallest total. Concrete details will be shown below.
{
""total_locations_including_garage"": 13,
""nodes"": [
{
""location_node_id"": 1,
""x_map_coordinate"": 61,
""y_map_coordinate"": 65,
""equipment_load_required"": 0
},
{
""location_node_id"": 2,
""x_map_coordinate"": 0,
""y_map_coordinate"": 80,
""equipment_load_required"": 80
},
{
""location_node_id"": 3,
""x_map_coordinate"": 53,
""y_map_coordinate"": 43,
""equipment_load_required"": 7
},
{
""location_node_id"": 4,
""x_map_coordinate"": 7,
""y_map_coordinate"": 69,
""equipment_load_required"": 4
},
{
""location_node_id"": 5,
""x_map_coordinate"": 76,
""y_map_coordinate"": 100,
""equipment_load_required"": 7
},
{
""location_node_id"": 6,
""x_map_coordinate"": 5,
""y_map_coordinate"": 39,
""equipment_load_required"": 4
},
{
""location_node_id"": 7,
""x_map_coordinate"": 45,
""y_map_coordinate"": 0,
""equipment_load_required"": 8
},
{
""location_node_id"": 8,
""x_map_coordinate"": 2,
""y_map_coordinate"": 74,
""equipment_load_required"": 2
},
{
""location_node_id"": 9,
""x_map_coordinate"": 12,
""y_map_coordinate"": 82,
""equipment_load_required"": 3
},
{
""location_node_id"": 10,
""x_map_coordinate"": 100,
""y_map_coordinate"": 69,
""equipment_load_required"": 8
},
{
""location_node_id"": 11,
""x_map_coordinate"": 17,
""y_map_coordinate"": 14,
""equipment_load_required"": 4
},
{
""location_node_id"": 12,
""x_map_coordinate"": 7,
""y_map_coordinate"": 1,
""equipment_load_required"": 10
},
{
""location_node_id"": 13,
""x_map_coordinate"": 18,
""y_map_coordinate"": 65,
""equipment_load_required"": 1
}
],
""garage_node_id"": 1,
""van_equipment_capacity"": 154
}
Also, when you send the routes back, just use this little JSON layout so everything is easy to read and machine-friendly:
{
""solution"": [[garage_id, call_id, ... , garage_id], [garage_id, call_id, ... , garage_id], ...]
}
Think of ""solution"" as the form field: it holds a list of runs. Each inner list is one van’s trip — it starts at the garage, lists the service calls in visit order, and finishes back at the garage. The placeholders above are just showing the shape, not the actual IDs you should use.
This JSON is only a sketch of the expected shape, not the final answer. Make sure to use the exact identifiers from the instance input — do not rename them or make up new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[61, 65], [0, 80], [53, 43], [7, 69], [76, 100], [5, 39], [45, 0], [2, 74], [12, 82], [100, 69], [17, 14], [7, 1], [18, 65]], 'depot': 0, 'demands': [0, 80, 7, 4, 7, 4, 8, 2, 3, 8, 4, 10, 1], 'capacity': 154, 'num_vehicles': 1, 'total_distance': 360.5194751118195, 'objective': 360.5194751118195}","[[0, 2, 6, 11, 10, 5, 12, 3, 7, 1, 8, 4, 9, 0]]",360.5194751118195,"{'problem_type': 'CVRP', 'num_nodes': 13, 'nodes': [{'id': 1, 'x': 61, 'y': 65, 'demand': 0}, {'id': 2, 'x': 0, 'y': 80, 'demand': 80}, {'id': 3, 'x': 53, 'y': 43, 'demand': 7}, {'id': 4, 'x': 7, 'y': 69, 'demand': 4}, {'id': 5, 'x': 76, 'y': 100, 'demand': 7}, {'id': 6, 'x': 5, 'y': 39, 'demand': 4}, {'id': 7, 'x': 45, 'y': 0, 'demand': 8}, {'id': 8, 'x': 2, 'y': 74, 'demand': 2}, {'id': 9, 'x': 12, 'y': 82, 'demand': 3}, {'id': 10, 'x': 100, 'y': 69, 'demand': 8}, {'id': 11, 'x': 17, 'y': 14, 'demand': 4}, {'id': 12, 'x': 7, 'y': 1, 'demand': 10}, {'id': 13, 'x': 18, 'y': 65, 'demand': 1}], 'depot': 1, 'capacity': 154, 'num_vehicles': 1, 'total_distance': 360.5194751118195, 'objective': 360.5194751118195}","[[1, 3, 7, 12, 11, 6, 13, 4, 8, 2, 9, 5, 10, 1]]",41,json,1
CVRP,CVRP,"Someone needs to assign the daily delivery runs from the DC so no house is missed or receives two parcels. The decision is about which addresses each van will cover and the order they’re visited, with each run starting and ending at the center and no van overloaded beyond what it can hold. The quality of a plan is judged by total travel distance: sum the distances of all runs and aim for the smallest total. The concrete details follow below.
There are 15 locations including the distribution center 0; each van can carry up to 120 parcels.
| location_id | x_coordinate | y_coordinate | parcel_demand |
|---|---|---|---|
| 0 | 57 | 42 | 0 |
| 1 | 50 | 19 | 26 |
| 2 | 25 | 50 | 11 |
| 3 | 45 | 32 | 19 |
| 4 | 57 | 84 | 26 |
| 5 | 93 | 34 | 12 |
| 6 | 93 | 16 | 8 |
| 7 | 25 | 35 | 19 |
| 8 | 100 | 0 | 22 |
| 9 | 42 | 100 | 25 |
| 10 | 25 | 55 | 17 |
| 11 | 10 | 39 | 5 |
| 12 | 80 | 39 | 19 |
| 13 | 82 | 69 | 22 |
| 14 | 0 | 18 | 26 |
Routes must start and end at 0, visit all 15 locations without exceeding 120 parcels per van, and minimize the total travel distance.
Oh, and when you send the actual plan back, please put it in a little JSON sketch like this so it's easy to read and use:
{
""solution"": [[depot_id, location_id, ... , depot_id], [depot_id, location_id, ... , depot_id], ...]
}
This just shows the shape I want: ""solution"" is a list of runs, each inner list is one van's route starting and ending at the depot_id, with the customer location_ids in visit order in between. It's an easy form — think of each inner list as the sequence a driver will follow. Note this is only an example of the expected shape, not the actual answer.
Please use the exact identifiers from the instance input — don't rename them or invent new ones.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[57, 42], [50, 19], [25, 50], [45, 32], [57, 84], [93, 34], [93, 16], [25, 35], [100, 0], [42, 100], [25, 55], [10, 39], [80, 39], [82, 69], [0, 18]], 'depot': 0, 'demands': [0, 26, 11, 19, 26, 12, 8, 19, 22, 25, 17, 5, 19, 22, 26], 'capacity': 120, 'num_vehicles': 3, 'total_distance': 445.3858800864254, 'objective': 445.3858800864254}","[[0, 13, 4, 9, 0], [0, 1, 8, 6, 5, 12, 0], [0, 3, 7, 14, 11, 2, 10, 0]]",445.3858800864254,"{'problem_type': 'CVRP', 'num_nodes': 15, 'nodes': [{'id': 0, 'x': 57, 'y': 42, 'demand': 0}, {'id': 1, 'x': 50, 'y': 19, 'demand': 26}, {'id': 2, 'x': 25, 'y': 50, 'demand': 11}, {'id': 3, 'x': 45, 'y': 32, 'demand': 19}, {'id': 4, 'x': 57, 'y': 84, 'demand': 26}, {'id': 5, 'x': 93, 'y': 34, 'demand': 12}, {'id': 6, 'x': 93, 'y': 16, 'demand': 8}, {'id': 7, 'x': 25, 'y': 35, 'demand': 19}, {'id': 8, 'x': 100, 'y': 0, 'demand': 22}, {'id': 9, 'x': 42, 'y': 100, 'demand': 25}, {'id': 10, 'x': 25, 'y': 55, 'demand': 17}, {'id': 11, 'x': 10, 'y': 39, 'demand': 5}, {'id': 12, 'x': 80, 'y': 39, 'demand': 19}, {'id': 13, 'x': 82, 'y': 69, 'demand': 22}, {'id': 14, 'x': 0, 'y': 18, 'demand': 26}], 'depot': 0, 'capacity': 120, 'num_vehicles': 3, 'total_distance': 445.3858800864254, 'objective': 445.3858800864254}","[[0, 13, 4, 9, 0], [0, 1, 8, 6, 5, 12, 0], [0, 3, 7, 14, 11, 2, 10, 0]]",42,markdown_table,0
CVRP,CVRP,"Someone in the transportation office needs to sketch the bus schedules: choose which stops go together on each trip and the order to visit them so no stop is missed or visited twice, each trip starts and finishes at the depot, and no bus is overloaded beyond its seats. The win here is fewer miles on the road — add up the route distances for all buses and try to make that sum as small as possible. Exact stop locations and numbers are shown below.
Total locations 15, depot 1, bus seating capacity 100.
Location 1 at (28, 95) with student demand 0.
Location 2 at (48, 0) with student demand 6.
Location 3 at (87, 86) with student demand 20.
Location 4 at (15, 98) with student demand 11.
Location 5 at (20, 84) with student demand 18.
Location 6 at (89, 68) with student demand 19.
Location 7 at (91, 77) with student demand 2.
Location 8 at (0, 5) with student demand 9.
Location 9 at (89, 9) with student demand 2.
Location 10 at (100, 84) with student demand 2.
Location 11 at (33, 100) with student demand 21.
Location 12 at (61, 0) with student demand 20.
Location 13 at (57, 2) with student demand 48.
Location 14 at (15, 77) with student demand 1.
Location 15 at (96, 82) with student demand 22.
Use these 15 locations and depot 1 with bus seating capacity 100 to sketch routes that visit each stop exactly once, start and end at the depot, and respect capacity while minimizing total miles.
Also, when you send the planned trips back, just use this simple JSON shape so it's easy to parse:
{
""solution"": [[depot_id, location_id, ... , depot_id], [depot_id, location_id, ... , depot_id], ...]
}
Think of ""solution"" as a list of bus trips. Each inner list is one trip: the first item is the depot, then the stops in the order the bus will visit them, and then the depot again at the end. It's just a sketch of the shape I need, not the actual answer.
Please make sure to use the exact stop and depot identifiers from the instance input — don't rename them or invent new ones. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'coordinates': [[28, 95], [48, 0], [87, 86], [15, 98], [20, 84], [89, 68], [91, 77], [0, 5], [89, 9], [100, 84], [33, 100], [61, 0], [57, 2], [15, 77], [96, 82]], 'depot': 0, 'demands': [0, 6, 20, 11, 18, 19, 2, 9, 2, 2, 21, 20, 48, 1, 22], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 495.37035652439266, 'objective': 495.37035652439266}","[[0, 4, 0], [0, 8, 11, 12, 1, 7, 13, 3, 0], [0, 5, 6, 14, 9, 2, 10, 0]]",495.37035652439266,"{'problem_type': 'CVRP', 'num_nodes': 15, 'nodes': [{'id': 1, 'x': 28, 'y': 95, 'demand': 0}, {'id': 2, 'x': 48, 'y': 0, 'demand': 6}, {'id': 3, 'x': 87, 'y': 86, 'demand': 20}, {'id': 4, 'x': 15, 'y': 98, 'demand': 11}, {'id': 5, 'x': 20, 'y': 84, 'demand': 18}, {'id': 6, 'x': 89, 'y': 68, 'demand': 19}, {'id': 7, 'x': 91, 'y': 77, 'demand': 2}, {'id': 8, 'x': 0, 'y': 5, 'demand': 9}, {'id': 9, 'x': 89, 'y': 9, 'demand': 2}, {'id': 10, 'x': 100, 'y': 84, 'demand': 2}, {'id': 11, 'x': 33, 'y': 100, 'demand': 21}, {'id': 12, 'x': 61, 'y': 0, 'demand': 20}, {'id': 13, 'x': 57, 'y': 2, 'demand': 48}, {'id': 14, 'x': 15, 'y': 77, 'demand': 1}, {'id': 15, 'x': 96, 'y': 82, 'demand': 22}], 'depot': 1, 'capacity': 100, 'num_vehicles': 3, 'total_distance': 495.37035652439266, 'objective': 495.37035652439266}","[[1, 5, 1], [1, 9, 12, 13, 2, 8, 14, 4, 1], [1, 6, 7, 15, 10, 3, 11, 1]]",43,nl,1
CVRP,CVRP,"There’s a simple challenge on the table: route our fleet from the central hub to drop off each clinic’s vaccine allocation once, make sure each truck returns to the hub and never carries more than its safe load. One delivery plan beats another if it results in less total driving — compute that by adding the distance of every truck’s loop and comparing totals. The specific clinic addresses, demand numbers and truck capacities are shown below.
We have 11 locations including the hub 1, and each truck's safe load is 100.
| location_id | x_coordinate_km | y_coordinate_km | vaccine_units_required |
|---|---|---|---|
| 1 | 18 | 100 | 0 |
| 2 | 100 | 32 | 3 |
| 3 | 17 | 22 | 9 |
| 4 | 23 | 30 | 10 |
| 5 | 35 | 0 | 10 |
| 6 | 32 | 0 | 24 |
| 7 | 20 | 23 | 15 |
| 8 | 0 | 42 | 14 |
| 9 | 22 | 28 | 20 |
| 10 | 1 | 41 | 8 |
| 11 | 28 | 30 | 22 |
Assign routes so every truck starts and ends at 1 and never exceeds 100 in delivered units.
Oh, and when you send the delivery plan back, it'd be easiest if you stick to a simple JSON shape like this:
{
""solution"": [[hub_id, clinic_id, ... , hub_id], [hub_id, clinic_id, ... , hub_id], ...]
}
This just means ""solution"" holds a list of routes. Each route is a list that starts and ends at the hub_id and has the clinic_id values in the order they should be visited. Think of it as a quick form — it shows the layout we expect, not the actual route choices.
Important: use the exact identifiers from the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[18, 100], [100, 32], [17, 22], [23, 30], [35, 0], [32, 0], [20, 23], [0, 42], [22, 28], [1, 41], [28, 30]], 'depot': 0, 'demands': [0, 3, 9, 10, 10, 24, 15, 14, 20, 8, 22], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 447.5137455501798, 'objective': 447.5137455501798}","[[0, 1, 4, 5, 6, 2, 9, 7, 0], [0, 10, 8, 3, 0]]",447.5137455501798,"{'problem_type': 'CVRP', 'num_nodes': 11, 'nodes': [{'id': 1, 'x': 18, 'y': 100, 'demand': 0}, {'id': 2, 'x': 100, 'y': 32, 'demand': 3}, {'id': 3, 'x': 17, 'y': 22, 'demand': 9}, {'id': 4, 'x': 23, 'y': 30, 'demand': 10}, {'id': 5, 'x': 35, 'y': 0, 'demand': 10}, {'id': 6, 'x': 32, 'y': 0, 'demand': 24}, {'id': 7, 'x': 20, 'y': 23, 'demand': 15}, {'id': 8, 'x': 0, 'y': 42, 'demand': 14}, {'id': 9, 'x': 22, 'y': 28, 'demand': 20}, {'id': 10, 'x': 1, 'y': 41, 'demand': 8}, {'id': 11, 'x': 28, 'y': 30, 'demand': 22}], 'depot': 1, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 447.5137455501798, 'objective': 447.5137455501798}","[[1, 2, 5, 6, 7, 3, 10, 8, 1], [1, 11, 9, 4, 1]]",44,markdown_table,1
CVRP,CVRP,"Someone needs to sequence the pickup runs for several household moves starting from the yard: assign each pickup to a run so it’s visited one time only, make sure every run begins and ends at the yard, and don’t put more cargo on a truck than it can hold. The better plan is the one with the lowest combined driving distance — just total the distance of all runs and try to shrink that number. Details about the pickups and loads are given below.
# total_locations_including_yard=12
# yard_node_id=1
# truck_payload_capacity=100
location_id,location_x,location_y,pickup_demand
1,30,23,0
2,14,6,9
3,81,26,14
4,0,0,7
5,94,95,3
6,46,60,21
7,35,48,10
8,18,11,12
9,100,100,9
10,8,2,23
11,38,48,6
12,46,62,15
Also, when you send the pickup plan back, just stick to this simple JSON shape so it's easy to read and check:
{
""solution"": [[yard_id, pickup_id, ... , yard_id], [yard_id, pickup_id, ... , yard_id], ...]
}
Think of it like a short form: ""solution"" is the list of runs, each inner list is one run that starts at the yard, visits the pickups in order, and returns to the yard. The placeholders (yard_id, pickup_id) just stand in for the actual labels you'll use — this block is just a sketch of the expected shape, not the actual answer.
Please use the exact identifiers from the instance input when you fill this in — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[30, 23], [14, 6], [81, 26], [0, 0], [94, 95], [46, 60], [35, 48], [18, 11], [100, 100], [8, 2], [38, 48], [46, 62]], 'depot': 0, 'demands': [0, 9, 14, 7, 3, 21, 10, 12, 9, 23, 6, 15], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 315.0985538709497, 'objective': 315.0985538709497}","[[0, 2, 8, 4, 11, 5, 10, 6, 0], [0, 3, 9, 1, 7, 0]]",315.0985538709497,"{'problem_type': 'CVRP', 'num_nodes': 12, 'nodes': [{'id': 1, 'x': 30, 'y': 23, 'demand': 0}, {'id': 2, 'x': 14, 'y': 6, 'demand': 9}, {'id': 3, 'x': 81, 'y': 26, 'demand': 14}, {'id': 4, 'x': 0, 'y': 0, 'demand': 7}, {'id': 5, 'x': 94, 'y': 95, 'demand': 3}, {'id': 6, 'x': 46, 'y': 60, 'demand': 21}, {'id': 7, 'x': 35, 'y': 48, 'demand': 10}, {'id': 8, 'x': 18, 'y': 11, 'demand': 12}, {'id': 9, 'x': 100, 'y': 100, 'demand': 9}, {'id': 10, 'x': 8, 'y': 2, 'demand': 23}, {'id': 11, 'x': 38, 'y': 48, 'demand': 6}, {'id': 12, 'x': 46, 'y': 62, 'demand': 15}], 'depot': 1, 'capacity': 100, 'num_vehicles': 2, 'total_distance': 315.0985538709497, 'objective': 315.0985538709497}","[[1, 3, 9, 5, 12, 6, 11, 7, 1], [1, 4, 10, 2, 8, 1]]",45,csv,1
CVRP,CVRP,"I picture a day where a fleet of trucks fills up jerrycans at the reservoir and makes rounds to deliver water to every farm — each farm gets served one time only, and every truck drives out from the reservoir and comes back empty or with whatever’s left. The trick is to decide which farms each truck should visit so the total distance driven by all trucks is as small as possible; that total is just the sum of the miles each truck covers. Nothing can be skipped or visited twice, and no truck carries more water than it can hold. The specific farm stops, demands, and truck capacities are listed below.
Below I list 12 locations; the reservoir node is A, and each truck can carry up to 998 jerrycans.
| location_id | location_x | location_y | water_demand_jerrycans |
|---|---|---|---|
| A | 0 | 0 | 0 |
| B | 26 | 100 | 8 |
| C | 75 | 28 | 2 |
| D | 3 | 9 | 70 |
| E | 83 | 80 | 95 |
| F | 90 | 84 | 57 |
| G | 85 | 35 | 10 |
| H | 100 | 90 | 56 |
| I | 93 | 95 | 82 |
| J | 83 | 79 | 74 |
| K | 22 | 7 | 70 |
| L | 9 | 11 | 72 |
I have listed all 12 locations for routing from reservoir A with trucks that hold up to 998 jerrycans.
If you want the answer in a neat, machine-friendly form, just return the routes in this simple JSON shape — nothing fancy, just a list of runs for the trucks.
{
""solution"": [[""reservoir_id"", ""farm_id"", ... , ""reservoir_id""], [""reservoir_id"", ""farm_id"", ... , ""reservoir_id""], ...]
}
Think of ""solution"" as a list of truck trips. Each inner list is one trip: it starts at the reservoir (reservoir_id), then lists the farms visited (farm_id) in order, and finishes back at the reservoir. This is just the expected shape — a sketch of how I want the answer formatted, not the actual routes.
Please make sure to use the exact identifiers given in the instance input — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 0], [26, 100], [75, 28], [3, 9], [83, 80], [90, 84], [85, 35], [100, 90], [93, 95], [83, 79], [22, 7], [9, 11]], 'depot': 0, 'demands': [0, 8, 2, 70, 95, 57, 10, 56, 82, 74, 70, 72], 'capacity': 998, 'num_vehicles': 1, 'total_distance': 339.28078427844287, 'objective': 339.28078427844287}","[[0, 3, 11, 1, 8, 7, 5, 4, 9, 6, 2, 10, 0]]",339.28078427844287,"{'problem_type': 'CVRP', 'num_nodes': 12, 'nodes': [{'id': 'A', 'x': 0, 'y': 0, 'demand': 0}, {'id': 'B', 'x': 26, 'y': 100, 'demand': 8}, {'id': 'C', 'x': 75, 'y': 28, 'demand': 2}, {'id': 'D', 'x': 3, 'y': 9, 'demand': 70}, {'id': 'E', 'x': 83, 'y': 80, 'demand': 95}, {'id': 'F', 'x': 90, 'y': 84, 'demand': 57}, {'id': 'G', 'x': 85, 'y': 35, 'demand': 10}, {'id': 'H', 'x': 100, 'y': 90, 'demand': 56}, {'id': 'I', 'x': 93, 'y': 95, 'demand': 82}, {'id': 'J', 'x': 83, 'y': 79, 'demand': 74}, {'id': 'K', 'x': 22, 'y': 7, 'demand': 70}, {'id': 'L', 'x': 9, 'y': 11, 'demand': 72}], 'depot': 'A', 'capacity': 998, 'num_vehicles': 1, 'total_distance': 339.28078427844287, 'objective': 339.28078427844287}","[['A', 'D', 'L', 'B', 'I', 'H', 'F', 'E', 'J', 'G', 'C', 'K', 'A']]",46,markdown_table,names
CVRP,CVRP,"There’s a neighborhood vendor who stages the freezer van in a garage and needs to lay out routes so every customer gets served once and only once. Each circuit has to leave from and return to the garage, and the van can only hold a limited amount on any single outing, so no run can go over that capacity. The better routing setup is the one that results in less overall driving; you can check that by totaling the distance of every circuit and picking the smallest sum. The concrete stop list, demands, and capacity details are shown below.
The instance has 15 locations, the garage is 1, and the van can carry up to 69 on any outing.
Location 1 at (0, 82) requires 0 ice cream units.
Location 2 at (9, 44) requires 5 ice cream units.
Location 3 at (17, 0) requires 6 ice cream units.
Location 4 at (95, 100) requires 10 ice cream units.
Location 5 at (56, 19) requires 10 ice cream units.
Location 6 at (99, 70) requires 10 ice cream units.
Location 7 at (40, 32) requires 9 ice cream units.
Location 8 at (100, 37) requires 9 ice cream units.
Location 9 at (58, 35) requires 8 ice cream units.
Location 10 at (34, 18) requires 6 ice cream units.
Location 11 at (30, 10) requires 6 ice cream units.
Location 12 at (48, 99) requires 10 ice cream units.
Location 13 at (61, 24) requires 7 ice cream units.
Location 14 at (54, 24) requires 7 ice cream units.
Location 15 at (10, 41) requires 7 ice cream units.
Routes must start and end at 1, respect the 69 limit, and together serve all 15 listed locations with minimal total driving.
Also, when you send the actual routes back, please use a simple JSON shape like this so it's easy to parse.
{
""solution"": [[garage_id, customer_id, ... , garage_id], [garage_id, customer_id, ... , garage_id], ...]
}
This just shows the shape I expect: ""solution"" is a list of trips (each trip is an ordered list of stops that starts and ends at the garage). The placeholder names (garage_id, customer_id) are just examples to show the pattern — it's a sketch of the format, not the real answer.
Please be sure to use the exact identifiers from the instance input when you list stops — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[0, 82], [9, 44], [17, 0], [95, 100], [56, 19], [99, 70], [40, 32], [100, 37], [58, 35], [34, 18], [30, 10], [48, 99], [61, 24], [54, 24], [10, 41]], 'depot': 0, 'demands': [0, 5, 6, 10, 10, 10, 9, 9, 8, 6, 6, 10, 7, 7, 7], 'capacity': 69, 'num_vehicles': 2, 'total_distance': 503.3147330970283, 'objective': 503.3147330970283}","[[0, 8, 7, 5, 3, 11, 0], [0, 1, 14, 2, 10, 9, 4, 12, 13, 6, 0]]",503.3147330970283,"{'problem_type': 'CVRP', 'num_nodes': 15, 'nodes': [{'id': 1, 'x': 0, 'y': 82, 'demand': 0}, {'id': 2, 'x': 9, 'y': 44, 'demand': 5}, {'id': 3, 'x': 17, 'y': 0, 'demand': 6}, {'id': 4, 'x': 95, 'y': 100, 'demand': 10}, {'id': 5, 'x': 56, 'y': 19, 'demand': 10}, {'id': 6, 'x': 99, 'y': 70, 'demand': 10}, {'id': 7, 'x': 40, 'y': 32, 'demand': 9}, {'id': 8, 'x': 100, 'y': 37, 'demand': 9}, {'id': 9, 'x': 58, 'y': 35, 'demand': 8}, {'id': 10, 'x': 34, 'y': 18, 'demand': 6}, {'id': 11, 'x': 30, 'y': 10, 'demand': 6}, {'id': 12, 'x': 48, 'y': 99, 'demand': 10}, {'id': 13, 'x': 61, 'y': 24, 'demand': 7}, {'id': 14, 'x': 54, 'y': 24, 'demand': 7}, {'id': 15, 'x': 10, 'y': 41, 'demand': 7}], 'depot': 1, 'capacity': 69, 'num_vehicles': 2, 'total_distance': 503.3147330970283, 'objective': 503.3147330970283}","[[1, 9, 8, 6, 4, 12, 1], [1, 2, 15, 3, 11, 10, 5, 13, 14, 7, 1]]",47,nl,1
CVRP,CVRP,"There’s a parts manager trying to plan the day: assign which truck visits which repair sites so nobody gets missed or gets two deliveries. Each run needs to leave from the depot and return there, and no truck should be packed beyond its limit. The measure of a good plan is simple — total miles driven across all runs — so the trick is to make that total as low as it can be by choosing smart routes. The concrete details are shown below.
{
""total_locations"": 12,
""nodes"": [
{
""location_id"": 1,
""location_x"": 8,
""location_y"": 0,
""parts_required"": 0
},
{
""location_id"": 2,
""location_x"": 100,
""location_y"": 90,
""parts_required"": 69
},
{
""location_id"": 3,
""location_x"": 45,
""location_y"": 78,
""parts_required"": 12
},
{
""location_id"": 4,
""location_x"": 46,
""location_y"": 38,
""parts_required"": 15
},
{
""location_id"": 5,
""location_x"": 0,
""location_y"": 100,
""parts_required"": 16
},
{
""location_id"": 6,
""location_x"": 46,
""location_y"": 66,
""parts_required"": 4
},
{
""location_id"": 7,
""location_x"": 56,
""location_y"": 7,
""parts_required"": 23
},
{
""location_id"": 8,
""location_x"": 48,
""location_y"": 17,
""parts_required"": 24
},
{
""location_id"": 9,
""location_x"": 46,
""location_y"": 29,
""parts_required"": 4
},
{
""location_id"": 10,
""location_x"": 46,
""location_y"": 79,
""parts_required"": 14
},
{
""location_id"": 11,
""location_x"": 54,
""location_y"": 22,
""parts_required"": 3
},
{
""location_id"": 12,
""location_x"": 53,
""location_y"": 84,
""parts_required"": 20
}
],
""depot_id"": 1,
""vehicle_capacity"": 100
}
Also, when you send the plan back, please follow this simple JSON layout so I can parse it easily:
{
""solution"": [[""depot_id"", ""site_id"", ""depot_id""], [""depot_id"", ""site_id"", ""site_id"", ""depot_id""]]
}
This is just a quick sketch of the shape I expect: ""solution"" is a list of truck runs, each run is an ordered list that starts and ends at the depot (the first and last entry), and the names in the middle are the repair sites the truck will visit that day. Think of it like filling out a form — each inner list is one truck’s trip, in order.
This JSON is only the shape I want, not the actual answer — replace those placeholders with the exact identifiers from the instance when you submit your plan. Please do not rename or invent labels: use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[8, 0], [100, 90], [45, 78], [46, 38], [0, 100], [46, 66], [56, 7], [48, 17], [46, 29], [46, 79], [54, 22], [53, 84]], 'depot': 0, 'demands': [0, 69, 12, 15, 16, 4, 23, 24, 4, 14, 3, 20], 'capacity': 100, 'num_vehicles': 3, 'total_distance': 619.1354822002288, 'objective': 619.1354822002288}","[[0, 4, 11, 9, 2, 5, 3, 0], [0, 7, 10, 1, 8, 0], [0, 6, 0]]",619.1354822002288,"{'problem_type': 'CVRP', 'num_nodes': 12, 'nodes': [{'id': 1, 'x': 8, 'y': 0, 'demand': 0}, {'id': 2, 'x': 100, 'y': 90, 'demand': 69}, {'id': 3, 'x': 45, 'y': 78, 'demand': 12}, {'id': 4, 'x': 46, 'y': 38, 'demand': 15}, {'id': 5, 'x': 0, 'y': 100, 'demand': 16}, {'id': 6, 'x': 46, 'y': 66, 'demand': 4}, {'id': 7, 'x': 56, 'y': 7, 'demand': 23}, {'id': 8, 'x': 48, 'y': 17, 'demand': 24}, {'id': 9, 'x': 46, 'y': 29, 'demand': 4}, {'id': 10, 'x': 46, 'y': 79, 'demand': 14}, {'id': 11, 'x': 54, 'y': 22, 'demand': 3}, {'id': 12, 'x': 53, 'y': 84, 'demand': 20}], 'depot': 1, 'capacity': 100, 'num_vehicles': 3, 'total_distance': 619.1354822002288, 'objective': 619.1354822002288}","[[1, 5, 12, 10, 3, 6, 4, 1], [1, 8, 11, 2, 9, 1], [1, 7, 1]]",48,json,1
CVRP,CVRP,"Someone at the blood bank has to lay out the routes for the day, deciding which hospitals each vehicle should visit so nobody gets left out or served twice, every route begins and ends at the bank, and each cooler stays within its load limit. The practical aim is to keep the whole operation as short as possible in terms of driving: add up the miles of every route, and the plan with the lowest total is the preferred one. The exact run details and quantities appear below.
{
""total_locations"": 14,
""nodes"": [
{
""location_id"": ""A"",
""x_coordinate"": 24,
""y_coordinate"": 63,
""blood_units_required"": 0
},
{
""location_id"": ""B"",
""x_coordinate"": 36,
""y_coordinate"": 59,
""blood_units_required"": 2
},
{
""location_id"": ""C"",
""x_coordinate"": 83,
""y_coordinate"": 39,
""blood_units_required"": 12
},
{
""location_id"": ""D"",
""x_coordinate"": 0,
""y_coordinate"": 0,
""blood_units_required"": 20
},
{
""location_id"": ""E"",
""x_coordinate"": 28,
""y_coordinate"": 97,
""blood_units_required"": 13
},
{
""location_id"": ""F"",
""x_coordinate"": 100,
""y_coordinate"": 3,
""blood_units_required"": 6
},
{
""location_id"": ""G"",
""x_coordinate"": 18,
""y_coordinate"": 30,
""blood_units_required"": 1
},
{
""location_id"": ""H"",
""x_coordinate"": 52,
""y_coordinate"": 86,
""blood_units_required"": 18
},
{
""location_id"": ""I"",
""x_coordinate"": 35,
""y_coordinate"": 84,
""blood_units_required"": 10
},
{
""location_id"": ""J"",
""x_coordinate"": 81,
""y_coordinate"": 46,
""blood_units_required"": 18
},
{
""location_id"": ""K"",
""x_coordinate"": 61,
""y_coordinate"": 100,
""blood_units_required"": 22
},
{
""location_id"": ""L"",
""x_coordinate"": 74,
""y_coordinate"": 21,
""blood_units_required"": 15
},
{
""location_id"": ""M"",
""x_coordinate"": 82,
""y_coordinate"": 1,
""blood_units_required"": 19
},
{
""location_id"": ""N"",
""x_coordinate"": 100,
""y_coordinate"": 33,
""blood_units_required"": 3
}
],
""blood_bank_id"": ""A"",
""vehicle_capacity"": 100
}
I'll just lay out the shape I want the answer to take in case it helps — a simple JSON sketch showing the routes.
{
""solution"": [[bank_id, hospital_id, ... , bank_id], [bank_id, hospital_id, ... , bank_id], ...]
}
This means ""solution"" is a list of vehicle routes. Each inner list is one route: it starts at the bank (bank_id), lists the hospitals visited (hospital_id placeholders) in the order they are driven to, and then returns to the bank (bank_id). The ""..."" just indicates any number of stops on a route. It's just a plain sketch of the expected shape, not the actual plan.
Please use the exact identifiers from the instance input when you give the real routes — do not rename them or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[24, 63], [36, 59], [83, 39], [0, 0], [28, 97], [100, 3], [18, 30], [52, 86], [35, 84], [81, 46], [61, 100], [74, 21], [82, 1], [100, 33]], 'depot': 0, 'demands': [0, 2, 12, 20, 13, 6, 1, 18, 10, 18, 22, 15, 19, 3], 'capacity': 100, 'num_vehicles': 2, 'total_distance': 424.38343374784046, 'objective': 424.38343374784046}","[[0, 6, 3, 11, 12, 5, 13, 2, 9, 1, 0], [0, 8, 4, 10, 7, 0]]",424.38343374784046,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 24, 'y': 63, 'demand': 0}, {'id': 'B', 'x': 36, 'y': 59, 'demand': 2}, {'id': 'C', 'x': 83, 'y': 39, 'demand': 12}, {'id': 'D', 'x': 0, 'y': 0, 'demand': 20}, {'id': 'E', 'x': 28, 'y': 97, 'demand': 13}, {'id': 'F', 'x': 100, 'y': 3, 'demand': 6}, {'id': 'G', 'x': 18, 'y': 30, 'demand': 1}, {'id': 'H', 'x': 52, 'y': 86, 'demand': 18}, {'id': 'I', 'x': 35, 'y': 84, 'demand': 10}, {'id': 'J', 'x': 81, 'y': 46, 'demand': 18}, {'id': 'K', 'x': 61, 'y': 100, 'demand': 22}, {'id': 'L', 'x': 74, 'y': 21, 'demand': 15}, {'id': 'M', 'x': 82, 'y': 1, 'demand': 19}, {'id': 'N', 'x': 100, 'y': 33, 'demand': 3}], 'depot': 'A', 'capacity': 100, 'num_vehicles': 2, 'total_distance': 424.38343374784046, 'objective': 424.38343374784046}","[['A', 'G', 'D', 'L', 'M', 'F', 'N', 'C', 'J', 'B', 'A'], ['A', 'I', 'E', 'K', 'H', 'A']]",49,json,names
CVRP,CVRP,"In the neighborhood the collection center coordinates a handful of pickup runs: each run must start and end at the center, and every residence must be visited one time only. The question is how to assign houses to runs so each run’s bag total fits under the van’s capacity and no house is served more than once or missed. The preferred arrangement is the one that keeps total driving to a minimum — you get that number by adding the lengths of all the routes together. The specific list of stops, their bag demands and the van capacity are shown below.
Below are 14 locations, with the collection center at A and a van capacity of 248 bags.
| location_id | location_x | location_y | bags_demand |
|---|---|---|---|
| A | 64 | 1 | 0 |
| B | 52 | 18 | 99 |
| C | 0 | 49 | 9 |
| D | 36 | 0 | 56 |
| E | 48 | 87 | 49 |
| F | 51 | 83 | 30 |
| G | 32 | 8 | 85 |
| H | 99 | 65 | 74 |
| I | 90 | 66 | 58 |
| J | 18 | 5 | 81 |
| K | 95 | 88 | 70 |
| L | 96 | 71 | 52 |
| M | 100 | 73 | 63 |
| N | 66 | 100 | 34 |
Routes should start and end at A, must not exceed 248 bags, and must visit each stop exactly once.
Also, when you send back the plan, please stick to this simple JSON layout so I can easily pick apart each pickup run:
{
""solution"": [[center_id, house_id, ... , center_id], [center_id, house_id, ... , center_id], ...]
}
This little sketch means ""solution"" is a list of runs. Each inner list is one run that starts and ends at the collection center (center_id) and lists the houses visited in order (house_id, ...). Think of it like filling in a form: one array per van trip, with the center shown first and last.
This is just the shape I need, not the actual answer — please use it to return the real runs for the instance.
All identifiers must be used exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'coordinates': [[64, 1], [52, 18], [0, 49], [36, 0], [48, 87], [51, 83], [32, 8], [99, 65], [90, 66], [18, 5], [95, 88], [96, 71], [100, 73], [66, 100]], 'depot': 0, 'demands': [0, 99, 9, 56, 49, 30, 85, 74, 58, 81, 70, 52, 63, 34], 'capacity': 248, 'num_vehicles': 4, 'total_distance': 590.9288515399417, 'objective': 590.9288515399417}","[[0, 6, 9, 3, 0], [0, 7, 12, 11, 8, 0], [0, 10, 13, 4, 5, 2, 0], [0, 1, 0]]",590.9288515399417,"{'problem_type': 'CVRP', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 64, 'y': 1, 'demand': 0}, {'id': 'B', 'x': 52, 'y': 18, 'demand': 99}, {'id': 'C', 'x': 0, 'y': 49, 'demand': 9}, {'id': 'D', 'x': 36, 'y': 0, 'demand': 56}, {'id': 'E', 'x': 48, 'y': 87, 'demand': 49}, {'id': 'F', 'x': 51, 'y': 83, 'demand': 30}, {'id': 'G', 'x': 32, 'y': 8, 'demand': 85}, {'id': 'H', 'x': 99, 'y': 65, 'demand': 74}, {'id': 'I', 'x': 90, 'y': 66, 'demand': 58}, {'id': 'J', 'x': 18, 'y': 5, 'demand': 81}, {'id': 'K', 'x': 95, 'y': 88, 'demand': 70}, {'id': 'L', 'x': 96, 'y': 71, 'demand': 52}, {'id': 'M', 'x': 100, 'y': 73, 'demand': 63}, {'id': 'N', 'x': 66, 'y': 100, 'demand': 34}], 'depot': 'A', 'capacity': 248, 'num_vehicles': 4, 'total_distance': 590.9288515399417, 'objective': 590.9288515399417}","[['A', 'G', 'J', 'D', 'A'], ['A', 'H', 'M', 'L', 'I', 'A'], ['A', 'K', 'N', 'E', 'F', 'C', 'A'], ['A', 'B', 'A']]",50,markdown_table,names
|