File size: 190,516 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 | task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
TSPTW,TSPTW,"Someone on the morning shift needs to draw up a delivery route that leaves from the depot, goes to every customer exactly one time during that customer’s allowed delivery window, and comes back to the depot; it’s okay to pause and wait if a place isn’t open yet. The deciding factor is how few miles the whole circuit uses — simply add up the distances between consecutive stops to see which plan uses less driving. Every customer must be visited once, and the exact stops and time windows are shown below.
There are 11 locations (including depot 0); list each stop with coordinates and its allowed arrival window:
Stop 0 at (0, 0), available from 0 to 1067.
Stop 1 at (7, 3), available from 145 to 431.
Stop 2 at (13, 28), available from 284 to 536.
Stop 3 at (12, 72), available from 60 to 269.
Stop 4 at (4, 84), available from 22 to 300.
Stop 5 at (28, 59), available from 233 to 495.
Stop 6 at (56, 100), available from 7 to 296.
Stop 7 at (68, 100), available from 322 to 537.
Stop 8 at (68, 27), available from 70 to 282.
Stop 9 at (83, 100), available from 118 to 362.
Stop 10 at (100, 82), available from 167 to 389.
The route must start and end at 0 and visit every location within its time window.
Oh, and when you reply with a candidate route, please use this simple JSON shape so it's easy to read and check:
{
""solution"": [depot_id, location_id, ..., depot_id]
}
Here ""solution"" is just the ordered list of stops: start at the depot, visit every customer once (in the order shown in the array), and finish back at the depot. Think of the bits in brackets as a form where you list the stop identifiers in travel order — it's just a sketch of the shape I need, not the actual route.
Please be 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], [7, 3], [13, 28], [12, 72], [4, 84], [28, 59], [56, 100], [68, 100], [68, 27], [83, 100], [100, 82]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [145, 431], [284, 536], [60, 269], [22, 300], [233, 495], [7, 296], [322, 537], [70, 282], [118, 362], [167, 389]], 'tour_length': 469.37699024953946, 'objective': 469.37699024953946}","[0, 8, 1, 3, 4, 6, 7, 9, 10, 5, 2, 0]",469.37699024953946,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 0, 'y': 0, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 7, 'y': 3, 'tw_start': 145, 'tw_end': 431}, {'id': 2, 'x': 13, 'y': 28, 'tw_start': 284, 'tw_end': 536}, {'id': 3, 'x': 12, 'y': 72, 'tw_start': 60, 'tw_end': 269}, {'id': 4, 'x': 4, 'y': 84, 'tw_start': 22, 'tw_end': 300}, {'id': 5, 'x': 28, 'y': 59, 'tw_start': 233, 'tw_end': 495}, {'id': 6, 'x': 56, 'y': 100, 'tw_start': 7, 'tw_end': 296}, {'id': 7, 'x': 68, 'y': 100, 'tw_start': 322, 'tw_end': 537}, {'id': 8, 'x': 68, 'y': 27, 'tw_start': 70, 'tw_end': 282}, {'id': 9, 'x': 83, 'y': 100, 'tw_start': 118, 'tw_end': 362}, {'id': 10, 'x': 100, 'y': 82, 'tw_start': 167, 'tw_end': 389}], 'depot': 0, 'objective': 469.37699024953946}","[0, 8, 1, 3, 4, 6, 7, 9, 10, 5, 2, 0]",1,nl,0
TSPTW,TSPTW,"We have a supervisor who needs one round trip from the depot that hits every piece of equipment exactly once, arriving to each site only during its allowed arrival period, and then returns to the depot. The decision is which route and sequence to follow so those arrival intervals are met. What makes one route better than another is simple: the one with the smallest total travel distance wins — calculate that by summing the distances between each stop in the trip (including leaving from and returning to the garage). Waiting at a site until its window opens is allowed, but it doesn’t reduce the miles driven. The concrete details are listed below.
# total_locations_including_garage=11
# depot_node_id=A
# time windows are listed per node in the table
site_id,x_coord,y_coord,earliest_arrival_time,latest_arrival_time
A,76,66,0,1067
B,0,25,237,444
C,12,54,113,342
D,53,10,176,447
E,43,64,77,321
F,71,0,229,428
G,98,90,235,446
H,100,100,25,311
I,93,8,374,647
J,28,0,118,321
K,88,46,265,502
Oh, and when you send the route back, please put it in this simple JSON shape so I can read it easily:
{
""solution"": [garage_id, site_id, ..., garage_id]
}
This just means ""solution"" should be an ordered list showing the trip: start at the garage_id, visit each site_id once in the order you choose, and finish back at the garage_id. It's just a sketch of the shape I need, not your actual answer.
Please be careful 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': [[76, 66], [0, 25], [12, 54], [53, 10], [43, 64], [71, 0], [98, 90], [100, 100], [93, 8], [28, 0], [88, 46]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [237, 444], [113, 342], [176, 447], [77, 321], [229, 428], [235, 446], [25, 311], [374, 647], [118, 321], [265, 502]], 'tour_length': 494.8005635056315, 'objective': 494.8005635056315}","[0, 7, 4, 2, 1, 9, 3, 5, 10, 6, 8, 0]",494.8005635056315,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 76, 'y': 66, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 0, 'y': 25, 'tw_start': 237, 'tw_end': 444}, {'id': 'C', 'x': 12, 'y': 54, 'tw_start': 113, 'tw_end': 342}, {'id': 'D', 'x': 53, 'y': 10, 'tw_start': 176, 'tw_end': 447}, {'id': 'E', 'x': 43, 'y': 64, 'tw_start': 77, 'tw_end': 321}, {'id': 'F', 'x': 71, 'y': 0, 'tw_start': 229, 'tw_end': 428}, {'id': 'G', 'x': 98, 'y': 90, 'tw_start': 235, 'tw_end': 446}, {'id': 'H', 'x': 100, 'y': 100, 'tw_start': 25, 'tw_end': 311}, {'id': 'I', 'x': 93, 'y': 8, 'tw_start': 374, 'tw_end': 647}, {'id': 'J', 'x': 28, 'y': 0, 'tw_start': 118, 'tw_end': 321}, {'id': 'K', 'x': 88, 'y': 46, 'tw_start': 265, 'tw_end': 502}], 'depot': 'A', 'objective': 494.8005635056315}","['A', 'H', 'E', 'C', 'B', 'J', 'D', 'F', 'K', 'G', 'I', 'A']",2,csv,names
TSPTW,TSPTW,"Early on weekday mornings a routine takes shape: start at the house, drop off at school, stop at scheduled activities, and end back at the house, making sure each stop is visited once and only during its permitted time range. The choice is the order of stops — different orders change arrival times and miles driven, and the best order is the one that produces the smallest total miles driven. To get that number, add up the miles between each successive stop in the plan and include the final leg home; pausing to wait for a place to open is allowed. The concrete schedule and locations are shown below.
{
""total_stops_including_home"": 14,
""nodes"": [
{
""stop_id"": 1,
""map_x_coordinate"": 4,
""map_y_coordinate"": 89,
""earliest_allowed_arrival"": 0,
""latest_allowed_arrival"": 1067
},
{
""stop_id"": 2,
""map_x_coordinate"": 4,
""map_y_coordinate"": 100,
""earliest_allowed_arrival"": 47,
""latest_allowed_arrival"": 289
},
{
""stop_id"": 3,
""map_x_coordinate"": 0,
""map_y_coordinate"": 89,
""earliest_allowed_arrival"": 13,
""latest_allowed_arrival"": 295
},
{
""stop_id"": 4,
""map_x_coordinate"": 0,
""map_y_coordinate"": 14,
""earliest_allowed_arrival"": 100,
""latest_allowed_arrival"": 358
},
{
""stop_id"": 5,
""map_x_coordinate"": 0,
""map_y_coordinate"": 24,
""earliest_allowed_arrival"": 120,
""latest_allowed_arrival"": 365
},
{
""stop_id"": 6,
""map_x_coordinate"": 12,
""map_y_coordinate"": 30,
""earliest_allowed_arrival"": 212,
""latest_allowed_arrival"": 424
},
{
""stop_id"": 7,
""map_x_coordinate"": 71,
""map_y_coordinate"": 59,
""earliest_allowed_arrival"": 376,
""latest_allowed_arrival"": 645
},
{
""stop_id"": 8,
""map_x_coordinate"": 76,
""map_y_coordinate"": 27,
""earliest_allowed_arrival"": 364,
""latest_allowed_arrival"": 645
},
{
""stop_id"": 9,
""map_x_coordinate"": 24,
""map_y_coordinate"": 14,
""earliest_allowed_arrival"": 231,
""latest_allowed_arrival"": 515
},
{
""stop_id"": 10,
""map_x_coordinate"": 37,
""map_y_coordinate"": 24,
""earliest_allowed_arrival"": 34,
""latest_allowed_arrival"": 247
},
{
""stop_id"": 11,
""map_x_coordinate"": 47,
""map_y_coordinate"": 38,
""earliest_allowed_arrival"": 17,
""latest_allowed_arrival"": 243
},
{
""stop_id"": 12,
""map_x_coordinate"": 47,
""map_y_coordinate"": 11,
""earliest_allowed_arrival"": 150,
""latest_allowed_arrival"": 371
},
{
""stop_id"": 13,
""map_x_coordinate"": 76,
""map_y_coordinate"": 0,
""earliest_allowed_arrival"": 321,
""latest_allowed_arrival"": 550
},
{
""stop_id"": 14,
""map_x_coordinate"": 100,
""map_y_coordinate"": 11,
""earliest_allowed_arrival"": 109,
""latest_allowed_arrival"": 355
}
],
""home_node_id"": 1
}
If you want the plan in a simple machine-friendly form, just give it in this little JSON shape so it's easy to read and check:
{
""solution"": [""home_id"", ""stop_id"", ""..."", ""home_id""]
}
Here ""solution"" is the ordered list of place IDs — start at home, list each stop once in the order you'll visit them, and finish back at home. Think of it like filling in the blanks on a form: the first and last entry are your home/depot, and the items in between are the stops in visit order. This is just a sketch of the shape I expect, not the actual route.
Please make 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': [[4, 89], [4, 100], [0, 89], [0, 14], [0, 24], [12, 30], [71, 59], [76, 27], [24, 14], [37, 24], [47, 38], [47, 11], [76, 0], [100, 11]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [47, 289], [13, 295], [100, 358], [120, 365], [212, 424], [376, 645], [364, 645], [231, 515], [34, 247], [17, 243], [150, 371], [321, 550], [109, 355]], 'tour_length': 396.7418477596823, 'objective': 396.7418477596823}","[0, 2, 1, 10, 9, 5, 4, 3, 8, 11, 12, 13, 7, 6, 0]",396.7418477596823,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 1, 'x': 4, 'y': 89, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 4, 'y': 100, 'tw_start': 47, 'tw_end': 289}, {'id': 3, 'x': 0, 'y': 89, 'tw_start': 13, 'tw_end': 295}, {'id': 4, 'x': 0, 'y': 14, 'tw_start': 100, 'tw_end': 358}, {'id': 5, 'x': 0, 'y': 24, 'tw_start': 120, 'tw_end': 365}, {'id': 6, 'x': 12, 'y': 30, 'tw_start': 212, 'tw_end': 424}, {'id': 7, 'x': 71, 'y': 59, 'tw_start': 376, 'tw_end': 645}, {'id': 8, 'x': 76, 'y': 27, 'tw_start': 364, 'tw_end': 645}, {'id': 9, 'x': 24, 'y': 14, 'tw_start': 231, 'tw_end': 515}, {'id': 10, 'x': 37, 'y': 24, 'tw_start': 34, 'tw_end': 247}, {'id': 11, 'x': 47, 'y': 38, 'tw_start': 17, 'tw_end': 243}, {'id': 12, 'x': 47, 'y': 11, 'tw_start': 150, 'tw_end': 371}, {'id': 13, 'x': 76, 'y': 0, 'tw_start': 321, 'tw_end': 550}, {'id': 14, 'x': 100, 'y': 11, 'tw_start': 109, 'tw_end': 355}], 'depot': 1, 'objective': 396.7418477596823}","[1, 3, 2, 11, 10, 6, 5, 4, 9, 12, 13, 14, 8, 7, 1]",3,json,1
TSPTW,TSPTW,"At the flower shop the planner’s job is to arrange the same-day delivery run: start and finish at the shop, visit each address one time only, arrive within each recipient’s specified time period (it’s okay to pause and wait if arriving early), and keep the overall driving down. A wiser choice of order is the one that produces the smallest total kilometers driven — you work that out by summing the distances between each leg of the trip, including coming back to the shop. Nothing can be skipped or repeated, and every delivery must fit its time window. The specific stops, distances and time windows are listed below.
There are 11 stops including the shop A; each stop's coordinates and allowed arrival window are listed one per line below.
Stop A: coordinates (0, 38), arrival window 0 - 1067.
Stop B: coordinates (9, 97), arrival window 54 - 326.
Stop C: coordinates (12, 90), arrival window 28 - 318.
Stop D: coordinates (12, 37), arrival window 299 - 512.
Stop E: coordinates (26, 90), arrival window 2 - 275.
Stop F: coordinates (46, 100), arrival window 274 - 538.
Stop G: coordinates (56, 0), arrival window 299 - 500.
Stop H: coordinates (74, 35), arrival window 139 - 344.
Stop I: coordinates (75, 35), arrival window 334 - 589.
Stop J: coordinates (95, 41), arrival window 128 - 328.
Stop K: coordinates (100, 3), arrival window 120 - 346.
Visit every stop once, start and finish at A, and make the route for all 11 stops fit their time windows while keeping total kilometers minimal.
When you hand over the final delivery order, just pop it into this simple JSON layout so it's easy to read and process:
{
""solution"": [depot_id, location_id, ..., depot_id]
}
Think of ""solution"" as the ordered list of stops — start at the shop (depot), visit every address once, and come back to the shop at the end. The placeholders in the array are where you put the exact stop identifiers from the instance. This JSON is only a sketch of the shape I expect, not the actual route.
Please make sure you 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': [[0, 38], [9, 97], [12, 90], [12, 37], [26, 90], [46, 100], [56, 0], [74, 35], [75, 35], [95, 41], [100, 3]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [54, 326], [28, 318], [299, 512], [2, 275], [274, 538], [299, 500], [139, 344], [334, 589], [128, 328], [120, 346]], 'tour_length': 441.5893717762156, 'objective': 441.5893717762156}","[0, 2, 1, 4, 9, 10, 6, 7, 8, 5, 3, 0]",441.5893717762156,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 0, 'y': 38, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 9, 'y': 97, 'tw_start': 54, 'tw_end': 326}, {'id': 'C', 'x': 12, 'y': 90, 'tw_start': 28, 'tw_end': 318}, {'id': 'D', 'x': 12, 'y': 37, 'tw_start': 299, 'tw_end': 512}, {'id': 'E', 'x': 26, 'y': 90, 'tw_start': 2, 'tw_end': 275}, {'id': 'F', 'x': 46, 'y': 100, 'tw_start': 274, 'tw_end': 538}, {'id': 'G', 'x': 56, 'y': 0, 'tw_start': 299, 'tw_end': 500}, {'id': 'H', 'x': 74, 'y': 35, 'tw_start': 139, 'tw_end': 344}, {'id': 'I', 'x': 75, 'y': 35, 'tw_start': 334, 'tw_end': 589}, {'id': 'J', 'x': 95, 'y': 41, 'tw_start': 128, 'tw_end': 328}, {'id': 'K', 'x': 100, 'y': 3, 'tw_start': 120, 'tw_end': 346}], 'depot': 'A', 'objective': 441.5893717762156}","['A', 'C', 'B', 'E', 'J', 'K', 'G', 'H', 'I', 'F', 'D', 'A']",4,nl,names
TSPTW,TSPTW,"There’s an inspector route to plan: leave the office, visit every property one time, respect each property’s allowed inspection period, and return to the same office at the end. The only leeway is waiting until a property’s window opens, and the better route is the one with the smallest total travel distance — calculated by summing the distances between all the successive stops on the loop — and the specific stops and windows are shown below.
The plan covers 12 locations, with the office as 1:
| location_id | x_coordinate | y_coordinate | earliest_arrival_time | latest_arrival_time |
|---|---|---|---|---|
| 1 | 71 | 0 | 0 | 1067 |
| 2 | 0 | 9 | 283 | 538 |
| 3 | 20 | 19 | 344 | 584 |
| 4 | 100 | 21 | 46 | 309 |
| 5 | 66 | 36 | 295 | 543 |
| 6 | 92 | 37 | 299 | 541 |
| 7 | 56 | 38 | 202 | 438 |
| 8 | 75 | 55 | 9 | 214 |
| 9 | 50 | 88 | 12 | 267 |
| 10 | 93 | 94 | 121 | 365 |
| 11 | 58 | 97 | 352 | 570 |
| 12 | 41 | 100 | 159 | 426 |
Return to the office 1 after visiting all 12 locations; wait if necessary until windows open, and prefer the route with the smallest total travel distance.
When you send the planned route back, just use this simple JSON layout so it's easy to check automatically:
{
""solution"": [office_id, property_id, ..., office_id]
}
This just says: ""solution"" is the ordered loop — start at the office_id, list each property_id in the order you visit them, and come back to the same office_id at the end. The ""..."" means all the other stops go in between. It's just a sketch of the shape I need, not the actual route.
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': [[71, 0], [0, 9], [20, 19], [100, 21], [66, 36], [92, 37], [56, 38], [75, 55], [50, 88], [93, 94], [58, 97], [41, 100]], 'depot': 0, 'num_nodes': 12, 'time_windows': [[0, 1067], [283, 538], [344, 584], [46, 309], [295, 543], [299, 541], [202, 438], [9, 214], [12, 267], [121, 365], [352, 570], [159, 426]], 'tour_length': 494.28669025875394, 'objective': 494.28669025875394}","[0, 3, 7, 6, 8, 11, 9, 10, 5, 4, 2, 1, 0]",494.28669025875394,"{'problem_type': 'TSPTW', 'num_nodes': 12, 'nodes': [{'id': 1, 'x': 71, 'y': 0, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 0, 'y': 9, 'tw_start': 283, 'tw_end': 538}, {'id': 3, 'x': 20, 'y': 19, 'tw_start': 344, 'tw_end': 584}, {'id': 4, 'x': 100, 'y': 21, 'tw_start': 46, 'tw_end': 309}, {'id': 5, 'x': 66, 'y': 36, 'tw_start': 295, 'tw_end': 543}, {'id': 6, 'x': 92, 'y': 37, 'tw_start': 299, 'tw_end': 541}, {'id': 7, 'x': 56, 'y': 38, 'tw_start': 202, 'tw_end': 438}, {'id': 8, 'x': 75, 'y': 55, 'tw_start': 9, 'tw_end': 214}, {'id': 9, 'x': 50, 'y': 88, 'tw_start': 12, 'tw_end': 267}, {'id': 10, 'x': 93, 'y': 94, 'tw_start': 121, 'tw_end': 365}, {'id': 11, 'x': 58, 'y': 97, 'tw_start': 352, 'tw_end': 570}, {'id': 12, 'x': 41, 'y': 100, 'tw_start': 159, 'tw_end': 426}], 'depot': 1, 'objective': 494.28669025875394}","[1, 4, 8, 7, 9, 12, 10, 11, 6, 5, 3, 2, 1]",5,markdown_table,1
TSPTW,TSPTW,"There’s a vaccination team leader sketching out a route that leaves the clinic, goes to each community stop once within its assigned access window, and then comes back to base — arriving early and waiting for a site to open is okay. What makes a route preferable is how short the total drive is: add up the distance between each pair of consecutive stops (and the return to the clinic) and the smallest total wins. No site can be skipped or revisited, and the specific locations and windows are listed below.
They number 11, with clinic 0 as the tour start and end.
Stop 0 is at (0, 9), with access window 0 to 1067.
Stop 1 is at (7, 4), with access window 88 to 290.
Stop 2 is at (33, 84), with access window 112 to 322.
Stop 3 is at (45, 0), with access window 360 to 633.
Stop 4 is at (47, 26), with access window 245 to 524.
Stop 5 is at (51, 100), with access window 311 to 523.
Stop 6 is at (56, 41), with access window 346 to 592.
Stop 7 is at (66, 25), with access window 313 to 594.
Stop 8 is at (68, 41), with access window 123 to 328.
Stop 9 is at (80, 94), with access window 88 to 323.
Stop 10 is at (100, 61), with access window 317 to 594.
The leader will plan a loop visiting all 11 sites and returning to 0.
Oh, and when you send back the planned route, a casual little JSON shape like this is perfect — just a list that starts at the clinic, visits each stop once, and comes back to the clinic.
{
""solution"": [clinic_id, stop_id, ..., clinic_id]
}
Here ""solution"" is the tour: the sequence of place identifiers you plan to visit in order, starting and ending at the clinic and including every community stop exactly once. Think of it like filling out a short form: just drop the sequence of IDs in the array in the order the team will drive them. This example is only a sketch of the expected shape — not the actual answer.
Please be sure to use the identifiers 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, 9], [7, 4], [33, 84], [45, 0], [47, 26], [51, 100], [56, 41], [66, 25], [68, 41], [80, 94], [100, 61]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [88, 290], [112, 322], [360, 633], [245, 524], [311, 523], [346, 592], [313, 594], [123, 328], [88, 323], [317, 594]], 'tour_length': 426.89566818704435, 'objective': 426.89566818704435}","[0, 1, 8, 9, 2, 5, 10, 7, 6, 4, 3, 0]",426.89566818704435,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 0, 'y': 9, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 7, 'y': 4, 'tw_start': 88, 'tw_end': 290}, {'id': 2, 'x': 33, 'y': 84, 'tw_start': 112, 'tw_end': 322}, {'id': 3, 'x': 45, 'y': 0, 'tw_start': 360, 'tw_end': 633}, {'id': 4, 'x': 47, 'y': 26, 'tw_start': 245, 'tw_end': 524}, {'id': 5, 'x': 51, 'y': 100, 'tw_start': 311, 'tw_end': 523}, {'id': 6, 'x': 56, 'y': 41, 'tw_start': 346, 'tw_end': 592}, {'id': 7, 'x': 66, 'y': 25, 'tw_start': 313, 'tw_end': 594}, {'id': 8, 'x': 68, 'y': 41, 'tw_start': 123, 'tw_end': 328}, {'id': 9, 'x': 80, 'y': 94, 'tw_start': 88, 'tw_end': 323}, {'id': 10, 'x': 100, 'y': 61, 'tw_start': 317, 'tw_end': 594}], 'depot': 0, 'objective': 426.89566818704435}","[0, 1, 8, 9, 2, 5, 10, 7, 6, 4, 3, 0]",6,nl,0
TSPTW,TSPTW,"Someone juggling portrait sessions must plan a one-day loop: leave the studio, visit every client location once and during its booked time window, and finish back at the studio. What makes one plan better than another is simply how little driving it requires — add up all the travel legs (including the final leg back) and pick the route with the smallest total — and arriving early is okay since waiting for the slot to start is allowed. The concrete schedule and distances are shown below.
# total_locations_including_studio=14
# studio_node_id=A
# time windows are listed per node in the table
location_id,location_x_coord,location_y_coord,booking_start_time,booking_end_time
A,24,0,0,1067
B,31,0,2,246
C,19,15,161,377
D,8,15,46,273
E,0,25,365,591
F,16,29,201,463
G,32,29,141,429
H,48,43,373,591
I,59,56,192,416
J,16,70,110,308
K,100,84,236,479
L,18,95,19,241
M,11,99,352,569
N,33,100,56,297
If you'd like to hand me a proposed route, just pop it into this little JSON shape so it's easy to read and check:
{
""solution"": [studio_id, client_id, ..., studio_id]
}
Think of it like a short form: ""solution"" is the ordered list of stops — start at the studio, visit each client once in the order shown, and finish back at the studio. The placeholders are just that (a sketch of the shape I want), so replace studio_id and client_id with the actual stop identifiers from the instance when you submit a route.
Please make sure you 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': [[24, 0], [31, 0], [19, 15], [8, 15], [0, 25], [16, 29], [32, 29], [48, 43], [59, 56], [16, 70], [100, 84], [18, 95], [11, 99], [33, 100]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [2, 246], [161, 377], [46, 273], [365, 591], [201, 463], [141, 429], [373, 591], [192, 416], [110, 308], [236, 479], [19, 241], [352, 569], [56, 297]], 'tour_length': 528.7374899856832, 'objective': 528.7374899856832}","[0, 1, 3, 9, 11, 13, 10, 8, 6, 2, 5, 4, 12, 7, 0]",528.7374899856832,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 24, 'y': 0, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 31, 'y': 0, 'tw_start': 2, 'tw_end': 246}, {'id': 'C', 'x': 19, 'y': 15, 'tw_start': 161, 'tw_end': 377}, {'id': 'D', 'x': 8, 'y': 15, 'tw_start': 46, 'tw_end': 273}, {'id': 'E', 'x': 0, 'y': 25, 'tw_start': 365, 'tw_end': 591}, {'id': 'F', 'x': 16, 'y': 29, 'tw_start': 201, 'tw_end': 463}, {'id': 'G', 'x': 32, 'y': 29, 'tw_start': 141, 'tw_end': 429}, {'id': 'H', 'x': 48, 'y': 43, 'tw_start': 373, 'tw_end': 591}, {'id': 'I', 'x': 59, 'y': 56, 'tw_start': 192, 'tw_end': 416}, {'id': 'J', 'x': 16, 'y': 70, 'tw_start': 110, 'tw_end': 308}, {'id': 'K', 'x': 100, 'y': 84, 'tw_start': 236, 'tw_end': 479}, {'id': 'L', 'x': 18, 'y': 95, 'tw_start': 19, 'tw_end': 241}, {'id': 'M', 'x': 11, 'y': 99, 'tw_start': 352, 'tw_end': 569}, {'id': 'N', 'x': 33, 'y': 100, 'tw_start': 56, 'tw_end': 297}], 'depot': 'A', 'objective': 528.7374899856832}","['A', 'B', 'D', 'J', 'L', 'N', 'K', 'I', 'G', 'C', 'F', 'E', 'M', 'H', 'A']",7,csv,names
TSPTW,TSPTW,"Recently the crew schedule required a single-van tour that starts and ends at the depot, visits each customer property only once during its allowed service period, and avoids unnecessary back-and-forth. The winning route is the one with the smallest total driving distance, which you find by summing the distances of each leg of the trip; arriving early and waiting until a service window opens is allowed. The specific addresses, service windows and travel lengths are shown below.
# total_locations=15
# depot_node_id=1
# time windows are listed per node in the table
location_id,coord_x,coord_y,service_window_start,service_window_end
1,2,76,0,1067
2,44,50,382,599
3,54,38,260,528
4,61,36,92,356
5,70,74,142,398
6,100,27,245,491
7,70,4,35,310
8,35,2,124,336
9,64,24,15,267
10,0,60,262,458
11,64,9,198,414
12,69,100,250,461
13,45,6,268,499
14,30,51,363,570
15,85,0,132,337
When you send back the chosen tour, just use this simple JSON layout so it's easy to check:
{
""solution"": [depot_id, location_id, ..., depot_id]
}
This shows the shape I need: ""solution"" is the ordered list of stops — start at the depot, list each customer once in the order you'll visit them, and finish back at the depot. The snippet above is just a sketch of the format, not the actual route.
Please use the exact identifiers from the instance input when you fill that array — 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': [[2, 76], [44, 50], [54, 38], [61, 36], [70, 74], [100, 27], [70, 4], [35, 2], [64, 24], [0, 60], [64, 9], [69, 100], [45, 6], [30, 51], [85, 0]], 'depot': 0, 'num_nodes': 15, 'time_windows': [[0, 1067], [382, 599], [260, 528], [92, 356], [142, 398], [245, 491], [35, 310], [124, 336], [15, 267], [262, 458], [198, 414], [250, 461], [268, 499], [363, 570], [132, 337]], 'tour_length': 536.36529539223, 'objective': 536.36529539223}","[0, 3, 8, 7, 10, 6, 14, 5, 4, 11, 9, 12, 2, 1, 13, 0]",536.36529539223,"{'problem_type': 'TSPTW', 'num_nodes': 15, 'nodes': [{'id': 1, 'x': 2, 'y': 76, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 44, 'y': 50, 'tw_start': 382, 'tw_end': 599}, {'id': 3, 'x': 54, 'y': 38, 'tw_start': 260, 'tw_end': 528}, {'id': 4, 'x': 61, 'y': 36, 'tw_start': 92, 'tw_end': 356}, {'id': 5, 'x': 70, 'y': 74, 'tw_start': 142, 'tw_end': 398}, {'id': 6, 'x': 100, 'y': 27, 'tw_start': 245, 'tw_end': 491}, {'id': 7, 'x': 70, 'y': 4, 'tw_start': 35, 'tw_end': 310}, {'id': 8, 'x': 35, 'y': 2, 'tw_start': 124, 'tw_end': 336}, {'id': 9, 'x': 64, 'y': 24, 'tw_start': 15, 'tw_end': 267}, {'id': 10, 'x': 0, 'y': 60, 'tw_start': 262, 'tw_end': 458}, {'id': 11, 'x': 64, 'y': 9, 'tw_start': 198, 'tw_end': 414}, {'id': 12, 'x': 69, 'y': 100, 'tw_start': 250, 'tw_end': 461}, {'id': 13, 'x': 45, 'y': 6, 'tw_start': 268, 'tw_end': 499}, {'id': 14, 'x': 30, 'y': 51, 'tw_start': 363, 'tw_end': 570}, {'id': 15, 'x': 85, 'y': 0, 'tw_start': 132, 'tw_end': 337}], 'depot': 1, 'objective': 536.36529539223}","[1, 4, 9, 8, 11, 7, 15, 6, 5, 12, 10, 13, 3, 2, 14, 1]",8,csv,1
TSPTW,TSPTW,"Many people on the tour team have wrestled with the same homework: start at headquarters, go to each venue once during its agreed time window, and return to headquarters, all while trying to keep driving to a minimum. The decision is the order of stops; a better choice is the route with the lowest total driving distance — simply add up the distances for all legs of the trip — and it’s allowed to hang around and wait if a venue’s window hasn’t started yet. No stop can be skipped or revisited, and arrival times must respect the windows. The exact itinerary data appears below.
There are 13 locations in total — the headquarters is node 0.
Node 0 at (0, 24) must be visited within [0, 1067].
Node 1 at (6, 24) must be visited within [1, 211].
Node 2 at (14, 61) must be visited within [212, 474].
Node 3 at (12, 88) must be visited within [252, 468].
Node 4 at (35, 41) must be visited within [276, 493].
Node 5 at (40, 10) must be visited within [126, 392].
Node 6 at (40, 75) must be visited within [252, 528].
Node 7 at (60, 83) must be visited within [255, 504].
Node 8 at (72, 88) must be visited within [36, 266].
Node 9 at (74, 0) must be visited within [102, 320].
Node 10 at (96, 100) must be visited within [377, 609].
Node 11 at (100, 67) must be visited within [346, 601].
Node 12 at (100, 66) must be visited within [308, 551].
Use these records to construct a route that starts and ends at node 0 and visits all 13 locations within their time windows.
You can just send the planned route back in a tiny JSON snippet like this:
{
""solution"": [hq_id, venue_id, ..., hq_id]
}
This just means: put the ordered list of stops under ""solution"" — start with the HQ identifier, list each venue once in the visit order, and end with the HQ identifier again. The placeholders above are just showing the shape (hq_id is the depot/headquarters; venue_id stands for each visit location; ""..."" means the rest of the stops in between). Treat it like a simple form, not a full report.
Reminder: that JSON is only a sketch of the shape I expect, not the actual route. 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, 24], [6, 24], [14, 61], [12, 88], [35, 41], [40, 10], [40, 75], [60, 83], [72, 88], [74, 0], [96, 100], [100, 67], [100, 66]], 'depot': 0, 'num_nodes': 13, 'time_windows': [[0, 1067], [1, 211], [212, 474], [252, 468], [276, 493], [126, 392], [252, 528], [255, 504], [36, 266], [102, 320], [377, 609], [346, 601], [308, 551]], 'tour_length': 514.0430018876883, 'objective': 514.0430018876883}","[0, 1, 5, 9, 8, 7, 6, 3, 2, 4, 12, 11, 10, 0]",514.0430018876883,"{'problem_type': 'TSPTW', 'num_nodes': 13, 'nodes': [{'id': 0, 'x': 0, 'y': 24, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 6, 'y': 24, 'tw_start': 1, 'tw_end': 211}, {'id': 2, 'x': 14, 'y': 61, 'tw_start': 212, 'tw_end': 474}, {'id': 3, 'x': 12, 'y': 88, 'tw_start': 252, 'tw_end': 468}, {'id': 4, 'x': 35, 'y': 41, 'tw_start': 276, 'tw_end': 493}, {'id': 5, 'x': 40, 'y': 10, 'tw_start': 126, 'tw_end': 392}, {'id': 6, 'x': 40, 'y': 75, 'tw_start': 252, 'tw_end': 528}, {'id': 7, 'x': 60, 'y': 83, 'tw_start': 255, 'tw_end': 504}, {'id': 8, 'x': 72, 'y': 88, 'tw_start': 36, 'tw_end': 266}, {'id': 9, 'x': 74, 'y': 0, 'tw_start': 102, 'tw_end': 320}, {'id': 10, 'x': 96, 'y': 100, 'tw_start': 377, 'tw_end': 609}, {'id': 11, 'x': 100, 'y': 67, 'tw_start': 346, 'tw_end': 601}, {'id': 12, 'x': 100, 'y': 66, 'tw_start': 308, 'tw_end': 551}], 'depot': 0, 'objective': 514.0430018876883}","[0, 1, 5, 9, 8, 7, 6, 3, 2, 4, 12, 11, 10, 0]",9,nl,0
TSPTW,TSPTW,"Many people count on the mobile library, so the planner must lay out a single route that leaves the branch, visits every community stop once within its visiting window, and returns to the branch afterward. The idea is to pick the order that results in the least overall driving — compute that by adding up the distance of each leg from stop to stop and back home — and early arrivals can wait until a place opens. The detailed stops and their hours are listed below.
{
""total_stops_including_branch"": 12,
""nodes"": [
{
""stop_id"": 1,
""coordinate_x"": 3,
""coordinate_y"": 1,
""visit_window_start"": 0,
""visit_window_end"": 1067
},
{
""stop_id"": 2,
""coordinate_x"": 59,
""coordinate_y"": 0,
""visit_window_start"": 223,
""visit_window_end"": 465
},
{
""stop_id"": 3,
""coordinate_x"": 81,
""coordinate_y"": 0,
""visit_window_start"": 75,
""visit_window_end"": 339
},
{
""stop_id"": 4,
""coordinate_x"": 87,
""coordinate_y"": 5,
""visit_window_start"": 108,
""visit_window_end"": 305
},
{
""stop_id"": 5,
""coordinate_x"": 85,
""coordinate_y"": 18,
""visit_window_start"": 250,
""visit_window_end"": 461
},
{
""stop_id"": 6,
""coordinate_x"": 89,
""coordinate_y"": 41,
""visit_window_start"": 364,
""visit_window_end"": 651
},
{
""stop_id"": 7,
""coordinate_x"": 94,
""coordinate_y"": 43,
""visit_window_start"": 354,
""visit_window_end"": 584
},
{
""stop_id"": 8,
""coordinate_x"": 8,
""coordinate_y"": 61,
""visit_window_start"": 5,
""visit_window_end"": 290
},
{
""stop_id"": 9,
""coordinate_x"": 100,
""coordinate_y"": 76,
""visit_window_start"": 166,
""visit_window_end"": 453
},
{
""stop_id"": 10,
""coordinate_x"": 85,
""coordinate_y"": 90,
""visit_window_start"": 373,
""visit_window_end"": 650
},
{
""stop_id"": 11,
""coordinate_x"": 85,
""coordinate_y"": 83,
""visit_window_start"": 114,
""visit_window_end"": 345
},
{
""stop_id"": 12,
""coordinate_x"": 0,
""coordinate_y"": 100,
""visit_window_start"": 330,
""visit_window_end"": 554
}
],
""branch_node_id"": 1
}
You can just hand the route back in a tiny JSON snippet like this — an ordered list that starts and ends at the branch:
{
""solution"": [branch_id, stop_id, ..., branch_id]
}
This shows the shape I want: ""solution"" is the tour in visit order, the first entry is the branch (depot), the middle entries are the community stops in the order you plan to visit them, and the final entry is the branch again. It’s just a sketch of the expected shape, not the actual answer — please fill it with the exact IDs from the instance when you return the real route.
Please don’t 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': [[3, 1], [59, 0], [81, 0], [87, 5], [85, 18], [89, 41], [94, 43], [8, 61], [100, 76], [85, 90], [85, 83], [0, 100]], 'depot': 0, 'num_nodes': 12, 'time_windows': [[0, 1067], [223, 465], [75, 339], [108, 305], [250, 461], [364, 651], [354, 584], [5, 290], [166, 453], [373, 650], [114, 345], [330, 554]], 'tour_length': 519.9522356166823, 'objective': 519.9522356166823}","[0, 7, 1, 2, 3, 4, 10, 9, 8, 6, 5, 11, 0]",519.9522356166823,"{'problem_type': 'TSPTW', 'num_nodes': 12, 'nodes': [{'id': 1, 'x': 3, 'y': 1, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 59, 'y': 0, 'tw_start': 223, 'tw_end': 465}, {'id': 3, 'x': 81, 'y': 0, 'tw_start': 75, 'tw_end': 339}, {'id': 4, 'x': 87, 'y': 5, 'tw_start': 108, 'tw_end': 305}, {'id': 5, 'x': 85, 'y': 18, 'tw_start': 250, 'tw_end': 461}, {'id': 6, 'x': 89, 'y': 41, 'tw_start': 364, 'tw_end': 651}, {'id': 7, 'x': 94, 'y': 43, 'tw_start': 354, 'tw_end': 584}, {'id': 8, 'x': 8, 'y': 61, 'tw_start': 5, 'tw_end': 290}, {'id': 9, 'x': 100, 'y': 76, 'tw_start': 166, 'tw_end': 453}, {'id': 10, 'x': 85, 'y': 90, 'tw_start': 373, 'tw_end': 650}, {'id': 11, 'x': 85, 'y': 83, 'tw_start': 114, 'tw_end': 345}, {'id': 12, 'x': 0, 'y': 100, 'tw_start': 330, 'tw_end': 554}], 'depot': 1, 'objective': 519.9522356166823}","[1, 8, 2, 3, 4, 5, 11, 10, 9, 7, 6, 12, 1]",10,json,1
TSPTW,TSPTW,"Imagine organizing a calibration trip where the technician sets off from the lab, calls on each customer exactly once during that customer’s available time window (waiting is permitted if the tech gets there before the window), and finally returns to the lab. The measure of a good plan is straightforward: the total distance of the whole tour — sum every driving leg from start to finish — and the smaller that sum, the better the plan. The detailed instance information is listed below.
{
""total_locations_including_lab"": 11,
""nodes"": [
{
""site_id"": 0,
""site_x"": 100,
""site_y"": 70,
""available_from"": 0,
""available_until"": 1067
},
{
""site_id"": 1,
""site_x"": 99,
""site_y"": 67,
""available_from"": 65,
""available_until"": 313
},
{
""site_id"": 2,
""site_x"": 73,
""site_y"": 59,
""available_from"": 363,
""available_until"": 624
},
{
""site_id"": 3,
""site_x"": 0,
""site_y"": 53,
""available_from"": 221,
""available_until"": 424
},
{
""site_id"": 4,
""site_x"": 63,
""site_y"": 34,
""available_from"": 238,
""available_until"": 528
},
{
""site_id"": 5,
""site_x"": 60,
""site_y"": 32,
""available_from"": 54,
""available_until"": 298
},
{
""site_id"": 6,
""site_x"": 30,
""site_y"": 21,
""available_from"": 340,
""available_until"": 606
},
{
""site_id"": 7,
""site_x"": 48,
""site_y"": 21,
""available_from"": 270,
""available_until"": 532
},
{
""site_id"": 8,
""site_x"": 23,
""site_y"": 100,
""available_from"": 139,
""available_until"": 361
},
{
""site_id"": 9,
""site_x"": 24,
""site_y"": 99,
""available_from"": 314,
""available_until"": 586
},
{
""site_id"": 10,
""site_x"": 26,
""site_y"": 0,
""available_from"": 336,
""available_until"": 619
}
],
""lab_node_id"": 0
}
Oh, and when you send back the technician’s plan, please use this simple JSON layout so it’s really clear what the tour looks like:
{
""solution"": [""lab_id"", ""customer_id"", ..., ""lab_id""]
}
Here ""solution"" is just the tour listed in order — who the tech visits, starting and ending at the lab. Each item in the list is the identifier for that stop (the lab or a customer). Think of it like filling out a little itinerary form, not a technical file — just the sequence in plain identifiers.
This is only a sketch of the expected shape, not the actual answer — please return the real sequence when you’re ready.
All identifiers in your returned JSON must match exactly how 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': [[100, 70], [99, 67], [73, 59], [0, 53], [63, 34], [60, 32], [30, 21], [48, 21], [23, 100], [24, 99], [26, 0]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [65, 313], [363, 624], [221, 424], [238, 528], [54, 298], [340, 606], [270, 532], [139, 361], [314, 586], [336, 619]], 'tour_length': 355.69941008658355, 'objective': 355.69941008658355}","[0, 1, 4, 5, 9, 8, 3, 6, 10, 7, 2, 0]",355.69941008658355,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 100, 'y': 70, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 99, 'y': 67, 'tw_start': 65, 'tw_end': 313}, {'id': 2, 'x': 73, 'y': 59, 'tw_start': 363, 'tw_end': 624}, {'id': 3, 'x': 0, 'y': 53, 'tw_start': 221, 'tw_end': 424}, {'id': 4, 'x': 63, 'y': 34, 'tw_start': 238, 'tw_end': 528}, {'id': 5, 'x': 60, 'y': 32, 'tw_start': 54, 'tw_end': 298}, {'id': 6, 'x': 30, 'y': 21, 'tw_start': 340, 'tw_end': 606}, {'id': 7, 'x': 48, 'y': 21, 'tw_start': 270, 'tw_end': 532}, {'id': 8, 'x': 23, 'y': 100, 'tw_start': 139, 'tw_end': 361}, {'id': 9, 'x': 24, 'y': 99, 'tw_start': 314, 'tw_end': 586}, {'id': 10, 'x': 26, 'y': 0, 'tw_start': 336, 'tw_end': 619}], 'depot': 0, 'objective': 355.69941008658355}","[0, 1, 4, 5, 9, 8, 3, 6, 10, 7, 2, 0]",11,json,0
TSPTW,TSPTW,"Recently the bakery has started juggling a bunch of morning drop-offs: the driver must start at the bakery, visit each café and shop on the list a single time, and return to the bakery afterward. Every customer has a preferred time frame for deliveries, so the route needs to respect those windows (waiting is allowed if a place isn’t ready yet, but being late isn’t). Which delivery order is preferred comes down to total distance driven — sum up the distance between each stop in the route plus the return trip, and the smaller total is better. The exact stops, their windows and the travel distances are listed below.
There are 12 locations in total, counting the bakery as node 0.
| stop_id | coord_x | coord_y | earliest_arrival_time | latest_arrival_time |
|---|---|---|---|---|
| 0 | 12 | 57 | 0 | 1067 |
| 1 | 46 | 48 | 198 | 441 |
| 2 | 29 | 53 | 309 | 566 |
| 3 | 0 | 51 | 272 | 543 |
| 4 | 16 | 100 | 345 | 572 |
| 5 | 59 | 94 | 145 | 348 |
| 6 | 62 | 74 | 224 | 421 |
| 7 | 28 | 53 | 180 | 427 |
| 8 | 1 | 0 | 111 | 362 |
| 9 | 83 | 12 | 11 | 209 |
| 10 | 100 | 98 | 319 | 548 |
| 11 | 32 | 50 | 49 | 293 |
They list each stop so the driver’s route can respect the time windows while minimizing total distance.
When you’re ready to give the route, just pop it into a tiny JSON snippet like this so I can read it programmatically:
{
""solution"": [bakery_id, shop_id, ..., bakery_id]
}
Pretty simple — ""solution"" is the ordered list of stops: start at the bakery, visit each place once, and come back to the bakery. The placeholders (bakery_id, shop_id, etc.) are just showing the shape of the answer — they’re not the real identifiers, just a sketch.
Please make sure to use the exact identifiers from 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': [[12, 57], [46, 48], [29, 53], [0, 51], [16, 100], [59, 94], [62, 74], [28, 53], [1, 0], [83, 12], [100, 98], [32, 50]], 'depot': 0, 'num_nodes': 12, 'time_windows': [[0, 1067], [198, 441], [309, 566], [272, 543], [345, 572], [145, 348], [224, 421], [180, 427], [111, 362], [11, 209], [319, 548], [49, 293]], 'tour_length': 488.345601888962, 'objective': 488.345601888962}","[0, 8, 9, 1, 11, 7, 6, 5, 10, 4, 2, 3, 0]",488.345601888962,"{'problem_type': 'TSPTW', 'num_nodes': 12, 'nodes': [{'id': 0, 'x': 12, 'y': 57, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 46, 'y': 48, 'tw_start': 198, 'tw_end': 441}, {'id': 2, 'x': 29, 'y': 53, 'tw_start': 309, 'tw_end': 566}, {'id': 3, 'x': 0, 'y': 51, 'tw_start': 272, 'tw_end': 543}, {'id': 4, 'x': 16, 'y': 100, 'tw_start': 345, 'tw_end': 572}, {'id': 5, 'x': 59, 'y': 94, 'tw_start': 145, 'tw_end': 348}, {'id': 6, 'x': 62, 'y': 74, 'tw_start': 224, 'tw_end': 421}, {'id': 7, 'x': 28, 'y': 53, 'tw_start': 180, 'tw_end': 427}, {'id': 8, 'x': 1, 'y': 0, 'tw_start': 111, 'tw_end': 362}, {'id': 9, 'x': 83, 'y': 12, 'tw_start': 11, 'tw_end': 209}, {'id': 10, 'x': 100, 'y': 98, 'tw_start': 319, 'tw_end': 548}, {'id': 11, 'x': 32, 'y': 50, 'tw_start': 49, 'tw_end': 293}], 'depot': 0, 'objective': 488.345601888962}","[0, 8, 9, 1, 11, 7, 6, 5, 10, 4, 2, 3, 0]",12,markdown_table,0
TSPTW,TSPTW,"Someone is lining up a route for an art restorer who must leave the studio, work at every gallery on the list once within each gallery’s specific access slot, and end the day back at the studio. The practical choice is picking the order and arrival times; arriving early and waiting is OK, but every gallery has to be visited exactly once. The plan that’s better is simply the one that racks up the fewest total miles — calculated by adding each leg of the trip from studio through all galleries and back — and the detailed schedule and distances are shown below.
{
""total_locations_including_studio"": 12,
""nodes"": [
{
""location_id"": 0,
""map_x_coordinate"": 59,
""map_y_coordinate"": 83,
""access_window_start"": 0,
""access_window_end"": 1067
},
{
""location_id"": 1,
""map_x_coordinate"": 24,
""map_y_coordinate"": 94,
""access_window_start"": 298,
""access_window_end"": 513
},
{
""location_id"": 2,
""map_x_coordinate"": 4,
""map_y_coordinate"": 92,
""access_window_start"": 241,
""access_window_end"": 443
},
{
""location_id"": 3,
""map_x_coordinate"": 0,
""map_y_coordinate"": 100,
""access_window_start"": 20,
""access_window_end"": 265
},
{
""location_id"": 4,
""map_x_coordinate"": 0,
""map_y_coordinate"": 22,
""access_window_start"": 209,
""access_window_end"": 465
},
{
""location_id"": 5,
""map_x_coordinate"": 0,
""map_y_coordinate"": 50,
""access_window_start"": 281,
""access_window_end"": 570
},
{
""location_id"": 6,
""map_x_coordinate"": 24,
""map_y_coordinate"": 67,
""access_window_start"": 200,
""access_window_end"": 425
},
{
""location_id"": 7,
""map_x_coordinate"": 63,
""map_y_coordinate"": 25,
""access_window_start"": 308,
""access_window_end"": 528
},
{
""location_id"": 8,
""map_x_coordinate"": 8,
""map_y_coordinate"": 0,
""access_window_start"": 170,
""access_window_end"": 371
},
{
""location_id"": 9,
""map_x_coordinate"": 100,
""map_y_coordinate"": 53,
""access_window_start"": 9,
""access_window_end"": 297
},
{
""location_id"": 10,
""map_x_coordinate"": 71,
""map_y_coordinate"": 53,
""access_window_start"": 324,
""access_window_end"": 585
},
{
""location_id"": 11,
""map_x_coordinate"": 97,
""map_y_coordinate"": 81,
""access_window_start"": 158,
""access_window_end"": 369
}
],
""studio_node_id"": 0
}
And if you want the route in a tidy, machine-friendly snippet, I usually show it like this:
{
""solution"": [""studio_id"", ""gallery_id"", ..., ""studio_id""]
}
This just means ""solution"" is a simple ordered list: start at the studio, visit each gallery once (in the order listed), and come back to the studio. Treat the placeholders as labels you would swap for the actual IDs from the instance — it’s just a sketch of the shape I expect, not the real route.
Please be sure to use the exact identifiers from the instance input — do not 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': [[59, 83], [24, 94], [4, 92], [0, 100], [0, 22], [0, 50], [24, 67], [63, 25], [8, 0], [100, 53], [71, 53], [97, 81]], 'depot': 0, 'num_nodes': 12, 'time_windows': [[0, 1067], [298, 513], [241, 443], [20, 265], [209, 465], [281, 570], [200, 425], [308, 528], [170, 371], [9, 297], [324, 585], [158, 369]], 'tour_length': 568.2044284882414, 'objective': 568.2044284882414}","[0, 3, 11, 9, 8, 4, 5, 6, 2, 1, 7, 10, 0]",568.2044284882414,"{'problem_type': 'TSPTW', 'num_nodes': 12, 'nodes': [{'id': 0, 'x': 59, 'y': 83, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 24, 'y': 94, 'tw_start': 298, 'tw_end': 513}, {'id': 2, 'x': 4, 'y': 92, 'tw_start': 241, 'tw_end': 443}, {'id': 3, 'x': 0, 'y': 100, 'tw_start': 20, 'tw_end': 265}, {'id': 4, 'x': 0, 'y': 22, 'tw_start': 209, 'tw_end': 465}, {'id': 5, 'x': 0, 'y': 50, 'tw_start': 281, 'tw_end': 570}, {'id': 6, 'x': 24, 'y': 67, 'tw_start': 200, 'tw_end': 425}, {'id': 7, 'x': 63, 'y': 25, 'tw_start': 308, 'tw_end': 528}, {'id': 8, 'x': 8, 'y': 0, 'tw_start': 170, 'tw_end': 371}, {'id': 9, 'x': 100, 'y': 53, 'tw_start': 9, 'tw_end': 297}, {'id': 10, 'x': 71, 'y': 53, 'tw_start': 324, 'tw_end': 585}, {'id': 11, 'x': 97, 'y': 81, 'tw_start': 158, 'tw_end': 369}], 'depot': 0, 'objective': 568.2044284882414}","[0, 3, 11, 9, 8, 4, 5, 6, 2, 1, 7, 10, 0]",13,json,0
TSPTW,TSPTW,"Recently the city asked for a daily route that starts and ends at the maintenance yard, hits every street-tree inspection spot exactly once during its allotted time period, and keeps the miles driven to an absolute minimum. The way to tell which route is better is straightforward — total the distances for each leg of the trip (including leaving and returning to the yard); the route with the smallest total distance wins. Crews are allowed to wait if they get there early, but every point must be visited once and only once. The concrete details are shown below.
{
""total_locations_including_yard"": 14,
""nodes"": [
{
""inspection_point_id"": 1,
""x_coordinate"": 87,
""y_coordinate"": 62,
""time_window_start"": 0,
""time_window_end"": 1067
},
{
""inspection_point_id"": 2,
""x_coordinate"": 100,
""y_coordinate"": 80,
""time_window_start"": 190,
""time_window_end"": 430
},
{
""inspection_point_id"": 3,
""x_coordinate"": 4,
""y_coordinate"": 79,
""time_window_start"": 67,
""time_window_end"": 303
},
{
""inspection_point_id"": 4,
""x_coordinate"": 0,
""y_coordinate"": 59,
""time_window_start"": 154,
""time_window_end"": 408
},
{
""inspection_point_id"": 5,
""x_coordinate"": 18,
""y_coordinate"": 91,
""time_window_start"": 246,
""time_window_end"": 444
},
{
""inspection_point_id"": 6,
""x_coordinate"": 65,
""y_coordinate"": 33,
""time_window_start"": 145,
""time_window_end"": 400
},
{
""inspection_point_id"": 7,
""x_coordinate"": 27,
""y_coordinate"": 74,
""time_window_start"": 195,
""time_window_end"": 472
},
{
""inspection_point_id"": 8,
""x_coordinate"": 85,
""y_coordinate"": 9,
""time_window_start"": 255,
""time_window_end"": 465
},
{
""inspection_point_id"": 9,
""x_coordinate"": 25,
""y_coordinate"": 67,
""time_window_start"": 27,
""time_window_end"": 283
},
{
""inspection_point_id"": 10,
""x_coordinate"": 85,
""y_coordinate"": 52,
""time_window_start"": 10,
""time_window_end"": 261
},
{
""inspection_point_id"": 11,
""x_coordinate"": 5,
""y_coordinate"": 100,
""time_window_start"": 364,
""time_window_end"": 614
},
{
""inspection_point_id"": 12,
""x_coordinate"": 60,
""y_coordinate"": 85,
""time_window_start"": 150,
""time_window_end"": 407
},
{
""inspection_point_id"": 13,
""x_coordinate"": 78,
""y_coordinate"": 0,
""time_window_start"": 177,
""time_window_end"": 424
},
{
""inspection_point_id"": 14,
""x_coordinate"": 95,
""y_coordinate"": 2,
""time_window_start"": 365,
""time_window_end"": 596
}
],
""yard_node_identifier"": 1
}
Oh, and one more practical thing — when you give the route back, please put it in a tiny JSON object so it's easy to read and share. Something like this:
{
""solution"": [yard_id, spot_id, ..., yard_id]
}
This just means ""solution"" holds the ordered list: start at the maintenance yard, list each inspection spot in the order the crew will visit them, and finish back at the yard. The identifiers in the array are placeholders you would replace with the actual IDs from the instance — this snippet is just a sketch of the shape I expect, not the real route.
Please make sure you use the exact identifiers from the problem 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': [[87, 62], [100, 80], [4, 79], [0, 59], [18, 91], [65, 33], [27, 74], [85, 9], [25, 67], [85, 52], [5, 100], [60, 85], [78, 0], [95, 2]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [190, 430], [67, 303], [154, 408], [246, 444], [145, 400], [195, 472], [255, 465], [27, 283], [10, 261], [364, 614], [150, 407], [177, 424], [365, 596]], 'tour_length': 579.1343953480267, 'objective': 579.1343953480267}","[0, 9, 8, 3, 2, 6, 4, 11, 1, 5, 12, 13, 7, 10, 0]",579.1343953480267,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 1, 'x': 87, 'y': 62, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 100, 'y': 80, 'tw_start': 190, 'tw_end': 430}, {'id': 3, 'x': 4, 'y': 79, 'tw_start': 67, 'tw_end': 303}, {'id': 4, 'x': 0, 'y': 59, 'tw_start': 154, 'tw_end': 408}, {'id': 5, 'x': 18, 'y': 91, 'tw_start': 246, 'tw_end': 444}, {'id': 6, 'x': 65, 'y': 33, 'tw_start': 145, 'tw_end': 400}, {'id': 7, 'x': 27, 'y': 74, 'tw_start': 195, 'tw_end': 472}, {'id': 8, 'x': 85, 'y': 9, 'tw_start': 255, 'tw_end': 465}, {'id': 9, 'x': 25, 'y': 67, 'tw_start': 27, 'tw_end': 283}, {'id': 10, 'x': 85, 'y': 52, 'tw_start': 10, 'tw_end': 261}, {'id': 11, 'x': 5, 'y': 100, 'tw_start': 364, 'tw_end': 614}, {'id': 12, 'x': 60, 'y': 85, 'tw_start': 150, 'tw_end': 407}, {'id': 13, 'x': 78, 'y': 0, 'tw_start': 177, 'tw_end': 424}, {'id': 14, 'x': 95, 'y': 2, 'tw_start': 365, 'tw_end': 596}], 'depot': 1, 'objective': 579.1343953480267}","[1, 10, 9, 4, 3, 7, 5, 12, 2, 6, 13, 14, 8, 11, 1]",14,json,1
TSPTW,TSPTW,"Many days involve a single catering run: start at the kitchen, hit every event once within its promised arrival slot, and head back to the kitchen. The better the plan, the fewer miles driven overall — which you get by summing the distances for each leg in the route, including the return leg — and arriving early is fine because waiting for the arrival period is allowed. Every stop must be included exactly once. The specific event locations and their time windows are shown below.
# total_locations_including_depot=12
# kitchen_node_id=0
# time windows are listed per node in the table
location_id,x_coordinate,y_coordinate,earliest_allowed_arrival,latest_allowed_arrival
0,0,7,0,1067
1,5,90,372,654
2,9,100,75,276
3,21,100,39,234
4,100,94,36,296
5,100,84,27,252
6,79,66,327,524
7,24,0,316,537
8,39,13,45,307
9,79,100,244,523
10,54,58,285,557
11,46,99,109,320
Also, when you hand back the route, just stick to a simple JSON layout like this:
{
""solution"": [kitchen_id, event_id, ..., kitchen_id]
}
Think of that as a little route form: ""solution"" is the ordered list of stops (start at the kitchen, visit each event once, and come back to the kitchen). The placeholders there are just showing the shape I expect — replace them with the actual IDs from the instance when you send the real answer.
This JSON is only a sketch of the shape I want, not the actual route — please 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, 7], [5, 90], [9, 100], [21, 100], [100, 94], [100, 84], [79, 66], [24, 0], [39, 13], [79, 100], [54, 58], [46, 99]], 'depot': 0, 'num_nodes': 12, 'time_windows': [[0, 1067], [372, 654], [75, 276], [39, 234], [36, 296], [27, 252], [327, 524], [316, 537], [45, 307], [244, 523], [285, 557], [109, 320]], 'tour_length': 492.1469592236004, 'objective': 492.1469592236004}","[0, 8, 2, 3, 11, 5, 4, 9, 6, 10, 1, 7, 0]",492.1469592236004,"{'problem_type': 'TSPTW', 'num_nodes': 12, 'nodes': [{'id': 0, 'x': 0, 'y': 7, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 5, 'y': 90, 'tw_start': 372, 'tw_end': 654}, {'id': 2, 'x': 9, 'y': 100, 'tw_start': 75, 'tw_end': 276}, {'id': 3, 'x': 21, 'y': 100, 'tw_start': 39, 'tw_end': 234}, {'id': 4, 'x': 100, 'y': 94, 'tw_start': 36, 'tw_end': 296}, {'id': 5, 'x': 100, 'y': 84, 'tw_start': 27, 'tw_end': 252}, {'id': 6, 'x': 79, 'y': 66, 'tw_start': 327, 'tw_end': 524}, {'id': 7, 'x': 24, 'y': 0, 'tw_start': 316, 'tw_end': 537}, {'id': 8, 'x': 39, 'y': 13, 'tw_start': 45, 'tw_end': 307}, {'id': 9, 'x': 79, 'y': 100, 'tw_start': 244, 'tw_end': 523}, {'id': 10, 'x': 54, 'y': 58, 'tw_start': 285, 'tw_end': 557}, {'id': 11, 'x': 46, 'y': 99, 'tw_start': 109, 'tw_end': 320}], 'depot': 0, 'objective': 492.1469592236004}","[0, 8, 2, 3, 11, 5, 4, 9, 6, 10, 1, 7, 0]",15,csv,0
TSPTW,TSPTW,"I help plan outreach days for a nonprofit, where the idea is to leave the office, visit every beneficiary address one time only within the time slot each family agreed to, and come back to the office at the end of the day. The trick is to arrange the order of stops so the total driving distance is as small as possible — that total is just the sum of the distances between each stop in the route, including the trip back to the office — and it’s okay to wait at a location if its time window hasn’t opened yet. Concrete details are shown below.
{
""total_locations_including_office"": 12,
""nodes"": [
{
""location_id"": 1,
""location_x_coordinate"": 100,
""location_y_coordinate"": 67,
""earliest_arrival_time"": 0,
""latest_arrival_time"": 1067
},
{
""location_id"": 2,
""location_x_coordinate"": 0,
""location_y_coordinate"": 75,
""earliest_arrival_time"": 291,
""latest_arrival_time"": 563
},
{
""location_id"": 3,
""location_x_coordinate"": 82,
""location_y_coordinate"": 7,
""earliest_arrival_time"": 384,
""latest_arrival_time"": 618
},
{
""location_id"": 4,
""location_x_coordinate"": 42,
""location_y_coordinate"": 100,
""earliest_arrival_time"": 144,
""latest_arrival_time"": 413
},
{
""location_id"": 5,
""location_x_coordinate"": 85,
""location_y_coordinate"": 43,
""earliest_arrival_time"": 132,
""latest_arrival_time"": 416
},
{
""location_id"": 6,
""location_x_coordinate"": 57,
""location_y_coordinate"": 59,
""earliest_arrival_time"": 333,
""latest_arrival_time"": 568
},
{
""location_id"": 7,
""location_x_coordinate"": 70,
""location_y_coordinate"": 93,
""earliest_arrival_time"": 291,
""latest_arrival_time"": 558
},
{
""location_id"": 8,
""location_x_coordinate"": 69,
""location_y_coordinate"": 73,
""earliest_arrival_time"": 40,
""latest_arrival_time"": 321
},
{
""location_id"": 9,
""location_x_coordinate"": 59,
""location_y_coordinate"": 9,
""earliest_arrival_time"": 196,
""latest_arrival_time"": 470
},
{
""location_id"": 10,
""location_x_coordinate"": 80,
""location_y_coordinate"": 54,
""earliest_arrival_time"": 124,
""latest_arrival_time"": 405
},
{
""location_id"": 11,
""location_x_coordinate"": 40,
""location_y_coordinate"": 34,
""earliest_arrival_time"": 151,
""latest_arrival_time"": 346
},
{
""location_id"": 12,
""location_x_coordinate"": 55,
""location_y_coordinate"": 0,
""earliest_arrival_time"": 351,
""latest_arrival_time"": 554
}
],
""office_node_id"": 1
}
Also, when you send the route back, please follow this little JSON sketch for the answer format:
{
""solution"": [office_id, family_id, ..., office_id]
}
""solution"" is the ordered list of stops — start at the office, visit each family once, and return to the office at the end. The names there are just placeholders: office_id stands for the office/depot and family_id stands for each beneficiary address. The ""..."" is where all the other stops go. This is just the shape I need, not the actual route.
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': [[100, 67], [0, 75], [82, 7], [42, 100], [85, 43], [57, 59], [70, 93], [69, 73], [59, 9], [80, 54], [40, 34], [55, 0]], 'depot': 0, 'num_nodes': 12, 'time_windows': [[0, 1067], [291, 563], [384, 618], [144, 413], [132, 416], [333, 568], [291, 558], [40, 321], [196, 470], [124, 405], [151, 346], [351, 554]], 'tour_length': 432.78293195237, 'objective': 432.78293195237}","[0, 4, 9, 7, 10, 1, 3, 6, 5, 8, 11, 2, 0]",432.78293195237,"{'problem_type': 'TSPTW', 'num_nodes': 12, 'nodes': [{'id': 1, 'x': 100, 'y': 67, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 0, 'y': 75, 'tw_start': 291, 'tw_end': 563}, {'id': 3, 'x': 82, 'y': 7, 'tw_start': 384, 'tw_end': 618}, {'id': 4, 'x': 42, 'y': 100, 'tw_start': 144, 'tw_end': 413}, {'id': 5, 'x': 85, 'y': 43, 'tw_start': 132, 'tw_end': 416}, {'id': 6, 'x': 57, 'y': 59, 'tw_start': 333, 'tw_end': 568}, {'id': 7, 'x': 70, 'y': 93, 'tw_start': 291, 'tw_end': 558}, {'id': 8, 'x': 69, 'y': 73, 'tw_start': 40, 'tw_end': 321}, {'id': 9, 'x': 59, 'y': 9, 'tw_start': 196, 'tw_end': 470}, {'id': 10, 'x': 80, 'y': 54, 'tw_start': 124, 'tw_end': 405}, {'id': 11, 'x': 40, 'y': 34, 'tw_start': 151, 'tw_end': 346}, {'id': 12, 'x': 55, 'y': 0, 'tw_start': 351, 'tw_end': 554}], 'depot': 1, 'objective': 432.78293195237}","[1, 5, 10, 8, 11, 2, 4, 7, 6, 9, 12, 3, 1]",16,json,1
TSPTW,TSPTW,"We have a mobile groomer who needs to plan a day that starts and finishes at the shop, visits every booked client one time during that client’s appointment window, and is allowed to hang around if it gets there early. The choice to make is the visiting order; better orders are simply those where the total trip length (calculated by summing the distance between each pair of consecutive locations, including the legs from and back to the home base) is lower than other orders. The specific appointments and distances are listed below.
We have 14 total locations to consider and the home shop is 1.
We must visit location 1 at (49, 61) between 0 and 1067.
We must visit location 2 at (89, 100) between 123 and 410.
We must visit location 3 at (79, 58) between 368 and 618.
We must visit location 4 at (66, 64) between 245 and 482.
We must visit location 5 at (97, 99) between 113 and 339.
We must visit location 6 at (71, 37) between 260 and 527.
We must visit location 7 at (0, 21) between 307 and 577.
We must visit location 8 at (83, 0) between 35 and 277.
We must visit location 9 at (62, 12) between 22 and 269.
We must visit location 10 at (85, 38) between 171 and 451.
We must visit location 11 at (100, 21) between 136 and 341.
We must visit location 12 at (73, 20) between 55 and 323.
We must visit location 13 at (81, 77) between 239 and 443.
We must visit location 14 at (8, 10) between 32 and 294.
We will select the visiting order that minimizes the total trip length, summing distances between consecutive locations and including the return to the home shop.
Also, when you send back the visiting order, just stick to a tiny JSON outline like this so it's easy to read and parse:
{
""solution"": [shop_id, client_id, ..., shop_id]
}
Think of that as a simple form: ""solution"" is the ordered list of stops (start at the shop, visit each client once, and return to the shop). The bits in the array are placeholders showing the shape I need — replace them with the actual identifiers from the instance. This is just a sketch of the expected shape, not the real answer.
Please make sure to 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': [[49, 61], [89, 100], [79, 58], [66, 64], [97, 99], [71, 37], [0, 21], [83, 0], [62, 12], [85, 38], [100, 21], [73, 20], [81, 77], [8, 10]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [123, 410], [368, 618], [245, 482], [113, 339], [260, 527], [307, 577], [35, 277], [22, 269], [171, 451], [136, 341], [55, 323], [239, 443], [32, 294]], 'tour_length': 492.3826303893492, 'objective': 492.3826303893492}","[0, 13, 8, 11, 7, 10, 9, 4, 1, 12, 3, 2, 5, 6, 0]",492.3826303893492,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 1, 'x': 49, 'y': 61, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 89, 'y': 100, 'tw_start': 123, 'tw_end': 410}, {'id': 3, 'x': 79, 'y': 58, 'tw_start': 368, 'tw_end': 618}, {'id': 4, 'x': 66, 'y': 64, 'tw_start': 245, 'tw_end': 482}, {'id': 5, 'x': 97, 'y': 99, 'tw_start': 113, 'tw_end': 339}, {'id': 6, 'x': 71, 'y': 37, 'tw_start': 260, 'tw_end': 527}, {'id': 7, 'x': 0, 'y': 21, 'tw_start': 307, 'tw_end': 577}, {'id': 8, 'x': 83, 'y': 0, 'tw_start': 35, 'tw_end': 277}, {'id': 9, 'x': 62, 'y': 12, 'tw_start': 22, 'tw_end': 269}, {'id': 10, 'x': 85, 'y': 38, 'tw_start': 171, 'tw_end': 451}, {'id': 11, 'x': 100, 'y': 21, 'tw_start': 136, 'tw_end': 341}, {'id': 12, 'x': 73, 'y': 20, 'tw_start': 55, 'tw_end': 323}, {'id': 13, 'x': 81, 'y': 77, 'tw_start': 239, 'tw_end': 443}, {'id': 14, 'x': 8, 'y': 10, 'tw_start': 32, 'tw_end': 294}], 'depot': 1, 'objective': 492.3826303893492}","[1, 14, 9, 12, 8, 11, 10, 5, 2, 13, 4, 3, 6, 7, 1]",17,nl,1
TSPTW,TSPTW,"On a Monday morning a field rep sets out from the regional office, needs to visit every client one time while each is open for visits, and must end the day back at the office. The simplest way to judge different schedules is by total distance driven — just add up the length of each leg between stops and the trip home, and the plan with the lowest total is preferred. It’s fine to wait until a client’s window opens, but skipping or repeating visits isn’t allowed. The concrete list of stops, windows and distances is provided below.
It includes 11 locations in total, with the regional office recorded as 0.
| location_id | coordinate_x | coordinate_y | availability_start_time | availability_end_time |
|---|---|---|---|---|
| 0 | 28 | 100 | 0 | 1067 |
| 1 | 1 | 67 | 28 | 301 |
| 2 | 20 | 93 | 274 | 475 |
| 3 | 28 | 0 | 32 | 322 |
| 4 | 59 | 53 | 145 | 375 |
| 5 | 64 | 14 | 315 | 601 |
| 6 | 0 | 89 | 382 | 649 |
| 7 | 53 | 40 | 145 | 348 |
| 8 | 100 | 11 | 301 | 549 |
| 9 | 73 | 94 | 164 | 446 |
| 10 | 60 | 99 | 43 | 284 |
The field rep must start and finish at 0 and visit all 11 locations within their time windows.
Also, if you want to hand the route back to me in a machine-friendly way, a little JSON snippet like this is perfect — nothing fancy, just the sequence of stops from the office and back:
{
""solution"": [office_id, client_id, ..., office_id]
}
Pretty straightforward: the solution array is the visit order, starting at the office, listing each client once in the order you’ll visit them, and finishing back at the office. Think of each placeholder as “put the exact ID for that stop here.”
This is just a sketch of the shape I expect, not the actual route — please fill it in with the real identifiers from the instance.
Please be careful to use the identifiers exactly as they appear in the instance input — no renaming and no inventing 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': [[28, 100], [1, 67], [20, 93], [28, 0], [59, 53], [64, 14], [0, 89], [53, 40], [100, 11], [73, 94], [60, 99]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [28, 301], [274, 475], [32, 322], [145, 375], [315, 601], [382, 649], [145, 348], [301, 549], [164, 446], [43, 284]], 'tour_length': 468.28830450281157, 'objective': 468.28830450281157}","[0, 1, 10, 9, 4, 7, 3, 5, 8, 2, 6, 0]",468.28830450281157,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 28, 'y': 100, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 1, 'y': 67, 'tw_start': 28, 'tw_end': 301}, {'id': 2, 'x': 20, 'y': 93, 'tw_start': 274, 'tw_end': 475}, {'id': 3, 'x': 28, 'y': 0, 'tw_start': 32, 'tw_end': 322}, {'id': 4, 'x': 59, 'y': 53, 'tw_start': 145, 'tw_end': 375}, {'id': 5, 'x': 64, 'y': 14, 'tw_start': 315, 'tw_end': 601}, {'id': 6, 'x': 0, 'y': 89, 'tw_start': 382, 'tw_end': 649}, {'id': 7, 'x': 53, 'y': 40, 'tw_start': 145, 'tw_end': 348}, {'id': 8, 'x': 100, 'y': 11, 'tw_start': 301, 'tw_end': 549}, {'id': 9, 'x': 73, 'y': 94, 'tw_start': 164, 'tw_end': 446}, {'id': 10, 'x': 60, 'y': 99, 'tw_start': 43, 'tw_end': 284}], 'depot': 0, 'objective': 468.28830450281157}","[0, 1, 10, 9, 4, 7, 3, 5, 8, 2, 6, 0]",18,markdown_table,0
TSPTW,TSPTW,"Many people on the logistics team are focused on one simple problem: build a route that leaves the warehouse, visits every delivery address once during its assigned time slot, and returns to the warehouse while keeping total travel distance as low as possible. You evaluate any candidate route by summing the distances between each pair of consecutive stops (including the start and finish at the warehouse); the smaller that sum, the better. Waiting before a window opens is allowed, but repeating a stop or leaving one out isn’t. The detailed list of stops and windows is shown below.
You will find 15 locations listed here and the warehouse node id is 1.
Stop 1 at (19, 21) with delivery window [0, 1067].
Stop 2 at (36, 57) with delivery window [4, 243].
Stop 3 at (35, 70) with delivery window [21, 227].
Stop 4 at (23, 92) with delivery window [45, 302].
Stop 5 at (43, 92) with delivery window [289, 540].
Stop 6 at (67, 44) with delivery window [373, 603].
Stop 7 at (51, 58) with delivery window [110, 389].
Stop 8 at (68, 85) with delivery window [86, 374].
Stop 9 at (61, 85) with delivery window [4, 292].
Stop 10 at (67, 100) with delivery window [16, 297].
Stop 11 at (79, 93) with delivery window [204, 495].
Stop 12 at (100, 57) with delivery window [28, 276].
Stop 13 at (87, 92) with delivery window [376, 620].
Stop 14 at (99, 5) with delivery window [244, 505].
Stop 15 at (0, 0) with delivery window [176, 431].
Visit each of the 15 stops (start/finish at 1), observing every delivery window.
Also, when you give me the final route, please use this simple JSON shape so it's easy to parse:
{
""solution"": [warehouse_id, address_id, ..., warehouse_id]
}
Think of that as a little form: the first item is the warehouse where the truck leaves from, the middle items are the delivery addresses in the exact order you visit them, and the last item is the warehouse again (you come back at the end). This is just a sketch of the shape I expect — not the actual route.
Please be sure to use the identifiers exactly as they appear in 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': [[19, 21], [36, 57], [35, 70], [23, 92], [43, 92], [67, 44], [51, 58], [68, 85], [61, 85], [67, 100], [79, 93], [100, 57], [87, 92], [99, 5], [0, 0]], 'depot': 0, 'num_nodes': 15, 'time_windows': [[0, 1067], [4, 243], [21, 227], [45, 302], [289, 540], [373, 603], [110, 389], [86, 374], [4, 292], [16, 297], [204, 495], [28, 276], [376, 620], [244, 505], [176, 431]], 'tour_length': 630.2659270772839, 'objective': 630.2659270772839}","[0, 1, 2, 3, 6, 8, 7, 9, 10, 11, 13, 14, 4, 12, 5, 0]",630.2659270772839,"{'problem_type': 'TSPTW', 'num_nodes': 15, 'nodes': [{'id': 1, 'x': 19, 'y': 21, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 36, 'y': 57, 'tw_start': 4, 'tw_end': 243}, {'id': 3, 'x': 35, 'y': 70, 'tw_start': 21, 'tw_end': 227}, {'id': 4, 'x': 23, 'y': 92, 'tw_start': 45, 'tw_end': 302}, {'id': 5, 'x': 43, 'y': 92, 'tw_start': 289, 'tw_end': 540}, {'id': 6, 'x': 67, 'y': 44, 'tw_start': 373, 'tw_end': 603}, {'id': 7, 'x': 51, 'y': 58, 'tw_start': 110, 'tw_end': 389}, {'id': 8, 'x': 68, 'y': 85, 'tw_start': 86, 'tw_end': 374}, {'id': 9, 'x': 61, 'y': 85, 'tw_start': 4, 'tw_end': 292}, {'id': 10, 'x': 67, 'y': 100, 'tw_start': 16, 'tw_end': 297}, {'id': 11, 'x': 79, 'y': 93, 'tw_start': 204, 'tw_end': 495}, {'id': 12, 'x': 100, 'y': 57, 'tw_start': 28, 'tw_end': 276}, {'id': 13, 'x': 87, 'y': 92, 'tw_start': 376, 'tw_end': 620}, {'id': 14, 'x': 99, 'y': 5, 'tw_start': 244, 'tw_end': 505}, {'id': 15, 'x': 0, 'y': 0, 'tw_start': 176, 'tw_end': 431}], 'depot': 1, 'objective': 630.2659270772839}","[1, 2, 3, 4, 7, 9, 8, 10, 11, 12, 14, 15, 5, 13, 6, 1]",19,nl,1
TSPTW,TSPTW,"On a typical morning a community health worker straps on a GPS and a schedule: leave the clinic, visit each household once during its allotted appointment window (it’s acceptable to wait if arriving ahead of time), and return to the clinic at day’s end. The practical question is how to arrange the stops so the total miles driven are as small as possible — calculate that by adding every leg of the trip, from clinic to first house, between houses, and back to the clinic; the route with the lowest sum is preferable. No household can be missed or visited more than once, and every visit must fall inside its planned window. The concrete details will be shown below.
There are 12 locations including the clinic, which is node 1.
| household_node_id | x_coordinate_map | y_coordinate_map | visit_window_start_time | visit_window_end_time |
|---|---|---|---|---|
| 1 | 15 | 84 | 0 | 1067 |
| 2 | 100 | 70 | 226 | 508 |
| 3 | 81 | 66 | 17 | 238 |
| 4 | 66 | 58 | 368 | 649 |
| 5 | 83 | 57 | 176 | 430 |
| 6 | 87 | 56 | 107 | 319 |
| 7 | 53 | 53 | 179 | 408 |
| 8 | 61 | 52 | 226 | 427 |
| 9 | 28 | 20 | 378 | 667 |
| 10 | 0 | 100 | 270 | 516 |
| 11 | 2 | 99 | 120 | 393 |
| 12 | 96 | 0 | 265 | 475 |
These lines enumerate every location the worker must visit once within its allotted window.
When you send the route back, just stick to a tiny JSON layout so it's easy to read and machine-friendly. Something like this will do:
{
""solution"": [clinic_id, household_id, ..., clinic_id]
}
This shows the visit order: start at the clinic, go to each household in the listed sequence (you can wait if you arrive early), and finish back at the clinic. It's just a sketch of the shape I expect — not the actual route yet.
Please make sure you use the exact identifiers from the instance input, without renaming or inventing 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': [[15, 84], [100, 70], [81, 66], [66, 58], [83, 57], [87, 56], [53, 53], [61, 52], [28, 20], [0, 100], [2, 99], [96, 0]], 'depot': 0, 'num_nodes': 12, 'time_windows': [[0, 1067], [226, 508], [17, 238], [368, 649], [176, 430], [107, 319], [179, 408], [226, 427], [378, 667], [270, 516], [120, 393], [265, 475]], 'tour_length': 435.83557696493887, 'objective': 435.83557696493887}","[0, 10, 2, 1, 5, 4, 11, 3, 7, 6, 8, 9, 0]",435.83557696493887,"{'problem_type': 'TSPTW', 'num_nodes': 12, 'nodes': [{'id': 1, 'x': 15, 'y': 84, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 100, 'y': 70, 'tw_start': 226, 'tw_end': 508}, {'id': 3, 'x': 81, 'y': 66, 'tw_start': 17, 'tw_end': 238}, {'id': 4, 'x': 66, 'y': 58, 'tw_start': 368, 'tw_end': 649}, {'id': 5, 'x': 83, 'y': 57, 'tw_start': 176, 'tw_end': 430}, {'id': 6, 'x': 87, 'y': 56, 'tw_start': 107, 'tw_end': 319}, {'id': 7, 'x': 53, 'y': 53, 'tw_start': 179, 'tw_end': 408}, {'id': 8, 'x': 61, 'y': 52, 'tw_start': 226, 'tw_end': 427}, {'id': 9, 'x': 28, 'y': 20, 'tw_start': 378, 'tw_end': 667}, {'id': 10, 'x': 0, 'y': 100, 'tw_start': 270, 'tw_end': 516}, {'id': 11, 'x': 2, 'y': 99, 'tw_start': 120, 'tw_end': 393}, {'id': 12, 'x': 96, 'y': 0, 'tw_start': 265, 'tw_end': 475}], 'depot': 1, 'objective': 435.83557696493887}","[1, 11, 3, 2, 6, 5, 12, 4, 8, 7, 9, 10, 1]",20,markdown_table,1
TSPTW,TSPTW,"Many mornings the challenge is the same: leave the oven, pop into every cafe on the list once while they’re open, and return to the oven, all while keeping the odometer reading as low as possible. The best route is the one with the smallest total miles — calculated by summing every driving leg from one stop to the next and including the trips from and back to the oven. It’s okay to wait for an opening, but each cafe must be visited exactly one time. Exact locations, time windows and mileages follow below.
There are 11 stops in total, with the oven at node A.
Cafe A at (75, 97); open from 0 to 1067.
Cafe B at (67, 40); open from 298 to 584.
Cafe C at (44, 32); open from 329 to 547.
Cafe D at (29, 40); open from 174 to 381.
Cafe E at (92, 95); open from 370 to 622.
Cafe F at (28, 40); open from 88 to 347.
Cafe G at (78, 100); open from 239 to 468.
Cafe H at (49, 30); open from 44 to 303.
Cafe I at (25, 0); open from 201 to 470.
Cafe J at (0, 66); open from 201 to 478.
Cafe K at (100, 95); open from 214 to 462.
Visit each of the 11 stops exactly once and return to the oven at node A.
Oh, and when you send the actual route back, please use a little JSON snippet like this — just a tidy list that starts and ends at the oven:
{
""solution"": [oven_id, cafe_id, ..., oven_id]
}
Think of ""solution"" as the ordered list of stops: the first item is the oven, then every cafe exactly once in the order you’ll visit them, and then the oven again to finish. It’s just a simple checklist, not the final answer — a sketch of the shape I’m expecting.
Please 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”.","{'coordinates': [[75, 97], [67, 40], [44, 32], [29, 40], [92, 95], [28, 40], [78, 100], [49, 30], [25, 0], [0, 66], [100, 95]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [298, 584], [329, 547], [174, 381], [370, 622], [88, 347], [239, 468], [44, 303], [201, 470], [201, 478], [214, 462]], 'tour_length': 333.9599055431392, 'objective': 333.9599055431392}","[0, 9, 5, 3, 7, 8, 2, 1, 10, 4, 6, 0]",333.9599055431392,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 75, 'y': 97, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 67, 'y': 40, 'tw_start': 298, 'tw_end': 584}, {'id': 'C', 'x': 44, 'y': 32, 'tw_start': 329, 'tw_end': 547}, {'id': 'D', 'x': 29, 'y': 40, 'tw_start': 174, 'tw_end': 381}, {'id': 'E', 'x': 92, 'y': 95, 'tw_start': 370, 'tw_end': 622}, {'id': 'F', 'x': 28, 'y': 40, 'tw_start': 88, 'tw_end': 347}, {'id': 'G', 'x': 78, 'y': 100, 'tw_start': 239, 'tw_end': 468}, {'id': 'H', 'x': 49, 'y': 30, 'tw_start': 44, 'tw_end': 303}, {'id': 'I', 'x': 25, 'y': 0, 'tw_start': 201, 'tw_end': 470}, {'id': 'J', 'x': 0, 'y': 66, 'tw_start': 201, 'tw_end': 478}, {'id': 'K', 'x': 100, 'y': 95, 'tw_start': 214, 'tw_end': 462}], 'depot': 'A', 'objective': 333.9599055431392}","['A', 'J', 'F', 'D', 'H', 'I', 'C', 'B', 'K', 'E', 'G', 'A']",21,nl,names
TSPTW,TSPTW,"Out in the field the situation is straightforward: a technician drives out from the depot, visits a set of ATMs exactly one time each within their service windows, and finishes the loop back at the depot. The question is how to order and time the visits so every ATM is covered once, no visit falls outside its allowed time, and the whole trip is as short as possible — measure that by summing up the distance of every leg of the route. Waiting for a window to open is allowed. The concrete details are below.
{
""total_locations"": 14,
""nodes"": [
{
""location_id"": 1,
""x_coordinate"": 36,
""y_coordinate"": 93,
""service_window_start"": 0,
""service_window_end"": 1067
},
{
""location_id"": 2,
""x_coordinate"": 32,
""y_coordinate"": 93,
""service_window_start"": 340,
""service_window_end"": 573
},
{
""location_id"": 3,
""x_coordinate"": 47,
""y_coordinate"": 79,
""service_window_start"": 51,
""service_window_end"": 248
},
{
""location_id"": 4,
""x_coordinate"": 43,
""y_coordinate"": 34,
""service_window_start"": 292,
""service_window_end"": 547
},
{
""location_id"": 5,
""x_coordinate"": 31,
""y_coordinate"": 33,
""service_window_start"": 273,
""service_window_end"": 487
},
{
""location_id"": 6,
""x_coordinate"": 51,
""y_coordinate"": 33,
""service_window_start"": 52,
""service_window_end"": 248
},
{
""location_id"": 7,
""x_coordinate"": 4,
""y_coordinate"": 100,
""service_window_start"": 136,
""service_window_end"": 387
},
{
""location_id"": 8,
""x_coordinate"": 2,
""y_coordinate"": 99,
""service_window_start"": 152,
""service_window_end"": 388
},
{
""location_id"": 9,
""x_coordinate"": 0,
""y_coordinate"": 100,
""service_window_start"": 350,
""service_window_end"": 578
},
{
""location_id"": 10,
""x_coordinate"": 73,
""y_coordinate"": 0,
""service_window_start"": 199,
""service_window_end"": 469
},
{
""location_id"": 11,
""x_coordinate"": 3,
""y_coordinate"": 1,
""service_window_start"": 153,
""service_window_end"": 408
},
{
""location_id"": 12,
""x_coordinate"": 2,
""y_coordinate"": 0,
""service_window_start"": 334,
""service_window_end"": 620
},
{
""location_id"": 13,
""x_coordinate"": 100,
""y_coordinate"": 100,
""service_window_start"": 57,
""service_window_end"": 340
},
{
""location_id"": 14,
""x_coordinate"": 19,
""y_coordinate"": 99,
""service_window_start"": 190,
""service_window_end"": 409
}
],
""depot_node_id"": 1
}
Just toss the answer back in a tiny JSON object like this so it's easy to parse:
{
""solution"": [depot_id, location_id, ..., depot_id]
}
This little block means: the ""solution"" field carries the route as an ordered list that starts at the depot, visits each ATM exactly once (in the order shown), and finishes at the depot again. Think of it as the simple form you fill in with the place IDs — it's just the shape I expect, not the real route.
Please 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': [[36, 93], [32, 93], [47, 79], [43, 34], [31, 33], [51, 33], [4, 100], [2, 99], [0, 100], [73, 0], [3, 1], [2, 0], [100, 100], [19, 99]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [340, 573], [51, 248], [292, 547], [273, 487], [52, 248], [136, 387], [152, 388], [350, 578], [199, 469], [153, 408], [334, 620], [57, 340], [190, 409]], 'tour_length': 602.4832485845818, 'objective': 602.4832485845818}","[0, 12, 5, 2, 13, 6, 7, 10, 11, 9, 3, 4, 1, 8, 0]",602.4832485845818,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 1, 'x': 36, 'y': 93, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 32, 'y': 93, 'tw_start': 340, 'tw_end': 573}, {'id': 3, 'x': 47, 'y': 79, 'tw_start': 51, 'tw_end': 248}, {'id': 4, 'x': 43, 'y': 34, 'tw_start': 292, 'tw_end': 547}, {'id': 5, 'x': 31, 'y': 33, 'tw_start': 273, 'tw_end': 487}, {'id': 6, 'x': 51, 'y': 33, 'tw_start': 52, 'tw_end': 248}, {'id': 7, 'x': 4, 'y': 100, 'tw_start': 136, 'tw_end': 387}, {'id': 8, 'x': 2, 'y': 99, 'tw_start': 152, 'tw_end': 388}, {'id': 9, 'x': 0, 'y': 100, 'tw_start': 350, 'tw_end': 578}, {'id': 10, 'x': 73, 'y': 0, 'tw_start': 199, 'tw_end': 469}, {'id': 11, 'x': 3, 'y': 1, 'tw_start': 153, 'tw_end': 408}, {'id': 12, 'x': 2, 'y': 0, 'tw_start': 334, 'tw_end': 620}, {'id': 13, 'x': 100, 'y': 100, 'tw_start': 57, 'tw_end': 340}, {'id': 14, 'x': 19, 'y': 99, 'tw_start': 190, 'tw_end': 409}], 'depot': 1, 'objective': 602.4832485845818}","[1, 13, 6, 3, 14, 7, 8, 11, 12, 10, 4, 5, 2, 9, 1]",22,json,1
TSPTW,TSPTW,"We need to plan a route for a visiting nurse who starts and finishes at the clinic, visits each patient’s home one time only during that patient’s availability window, and can wait if she gets there early. The better plan is simply the one with the smallest total driving distance, calculated by summing the distance between each consecutive stop plus the return leg to the clinic. The concrete patient times and locations are shown below.
There are 11 locations in total and the clinic is node A.
We list location A at coordinates (63, 76) with availability window from 0 to 1067.
We list location B at coordinates (97, 16) with availability window from 178 to 467.
We list location C at coordinates (15, 73) with availability window from 191 to 417.
We list location D at coordinates (100, 96) with availability window from 245 to 463.
We list location E at coordinates (15, 28) with availability window from 29 to 235.
We list location F at coordinates (27, 12) with availability window from 49 to 258.
We list location G at coordinates (27, 45) with availability window from 53 to 310.
We list location H at coordinates (37, 11) with availability window from 70 to 298.
We list location I at coordinates (84, 100) with availability window from 347 to 587.
We list location J at coordinates (0, 26) with availability window from 259 to 469.
We list location K at coordinates (1, 0) with availability window from 74 to 272.
We will minimize total driving distance for a tour that starts and ends at clinic A.
Also, when you send back the nurse’s route, please use this simple JSON layout so it’s easy to read and parse:
{
""solution"": [clinic_id, patient_id, ..., clinic_id]
}
Think of that array as the ordered stops: start at the clinic, list each patient’s identifier in the order they should be visited (one time each), and finish back at the clinic. This is just a sketch of the shape I expect — don’t treat the example values as the actual answer.
Please make sure to 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”.","{'coordinates': [[63, 76], [97, 16], [15, 73], [100, 96], [15, 28], [27, 12], [27, 45], [37, 11], [84, 100], [0, 26], [1, 0]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [178, 467], [191, 417], [245, 463], [29, 235], [49, 258], [53, 310], [70, 298], [347, 587], [259, 469], [74, 272]], 'tour_length': 466.5581336532528, 'objective': 466.5581336532528}","[0, 7, 5, 10, 4, 6, 2, 9, 1, 3, 8, 0]",466.5581336532528,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 63, 'y': 76, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 97, 'y': 16, 'tw_start': 178, 'tw_end': 467}, {'id': 'C', 'x': 15, 'y': 73, 'tw_start': 191, 'tw_end': 417}, {'id': 'D', 'x': 100, 'y': 96, 'tw_start': 245, 'tw_end': 463}, {'id': 'E', 'x': 15, 'y': 28, 'tw_start': 29, 'tw_end': 235}, {'id': 'F', 'x': 27, 'y': 12, 'tw_start': 49, 'tw_end': 258}, {'id': 'G', 'x': 27, 'y': 45, 'tw_start': 53, 'tw_end': 310}, {'id': 'H', 'x': 37, 'y': 11, 'tw_start': 70, 'tw_end': 298}, {'id': 'I', 'x': 84, 'y': 100, 'tw_start': 347, 'tw_end': 587}, {'id': 'J', 'x': 0, 'y': 26, 'tw_start': 259, 'tw_end': 469}, {'id': 'K', 'x': 1, 'y': 0, 'tw_start': 74, 'tw_end': 272}], 'depot': 'A', 'objective': 466.5581336532528}","['A', 'H', 'F', 'K', 'E', 'G', 'C', 'J', 'B', 'D', 'I', 'A']",23,nl,names
TSPTW,TSPTW,"Someone in the studio booked a string of one-off shoots across the city and needs a sensible route: leave the studio, go to each shoot exactly once during its scheduled access period, and return to the studio at the end. It’s okay to arrive early and wait for a location to open, but every location must be visited once and only once. The easy way to compare plans is to add up the travel between stops (and the final trip home) — the plan with the least total distance is the better plan. The exact schedule and location details are provided below.
There are 12 locations in total, and the studio (depot) is node A.
| location_id | map_x_coordinate | map_y_coordinate | access_open_time | access_close_time |
|---|---|---|---|---|
| A | 0 | 88 | 0 | 1067 |
| B | 78 | 15 | 65 | 286 |
| C | 99 | 55 | 68 | 271 |
| D | 93 | 100 | 46 | 285 |
| E | 98 | 75 | 80 | 309 |
| F | 84 | 65 | 195 | 456 |
| G | 20 | 6 | 15 | 286 |
| H | 81 | 93 | 243 | 445 |
| I | 0 | 34 | 338 | 622 |
| J | 22 | 0 | 23 | 244 |
| K | 44 | 32 | 312 | 579 |
| L | 100 | 90 | 71 | 285 |
Start and finish the route at the studio (node A); visit every location once within its access window.
Oh, and when you send the route back, please use this simple JSON layout so it's easy to read and check:
{
""solution"": [studio_id, shoot_id, ..., studio_id]
}
Think of this like a little form: the ""solution"" field holds the ordered list of stops starting and ending at the studio. studio_id is the place we leave from and return to, each shoot_id is a shoot location visited once in the order shown, and the ... just means ""all the other stops in between"" — it's a sketch of the shape I need, not the actual route.
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': [[0, 88], [78, 15], [99, 55], [93, 100], [98, 75], [84, 65], [20, 6], [81, 93], [0, 34], [22, 0], [44, 32], [100, 90]], 'depot': 0, 'num_nodes': 12, 'time_windows': [[0, 1067], [65, 286], [68, 271], [46, 285], [80, 309], [195, 456], [15, 286], [243, 445], [338, 622], [23, 244], [312, 579], [71, 285]], 'tour_length': 433.197892230933, 'objective': 433.197892230933}","[0, 6, 9, 1, 2, 4, 11, 3, 7, 5, 10, 8, 0]",433.197892230933,"{'problem_type': 'TSPTW', 'num_nodes': 12, 'nodes': [{'id': 'A', 'x': 0, 'y': 88, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 78, 'y': 15, 'tw_start': 65, 'tw_end': 286}, {'id': 'C', 'x': 99, 'y': 55, 'tw_start': 68, 'tw_end': 271}, {'id': 'D', 'x': 93, 'y': 100, 'tw_start': 46, 'tw_end': 285}, {'id': 'E', 'x': 98, 'y': 75, 'tw_start': 80, 'tw_end': 309}, {'id': 'F', 'x': 84, 'y': 65, 'tw_start': 195, 'tw_end': 456}, {'id': 'G', 'x': 20, 'y': 6, 'tw_start': 15, 'tw_end': 286}, {'id': 'H', 'x': 81, 'y': 93, 'tw_start': 243, 'tw_end': 445}, {'id': 'I', 'x': 0, 'y': 34, 'tw_start': 338, 'tw_end': 622}, {'id': 'J', 'x': 22, 'y': 0, 'tw_start': 23, 'tw_end': 244}, {'id': 'K', 'x': 44, 'y': 32, 'tw_start': 312, 'tw_end': 579}, {'id': 'L', 'x': 100, 'y': 90, 'tw_start': 71, 'tw_end': 285}], 'depot': 'A', 'objective': 433.197892230933}","['A', 'G', 'J', 'B', 'C', 'E', 'L', 'D', 'H', 'F', 'K', 'I', 'A']",24,markdown_table,names
TSPTW,TSPTW,"At the office there’s a route to plan: dispatch the salesperson, have them visit each retailer exactly once while they’re doing demos, and get them back to base before day’s end. The question is which route and timing will let every visit occur inside its demo slot (it’s acceptable to wait if arriving early), and the route that’s best is the one that minimizes total miles driven — total travel equals the sum of every trip between points plus the trips from and to the office. Every retailer must be visited one time only. The concrete times and places are listed below.
{
""total_locations_including_office"": 11,
""nodes"": [
{
""location_id"": 1,
""x_coordinate"": 4,
""y_coordinate"": 34,
""demo_start_time"": 0,
""demo_end_time"": 1067
},
{
""location_id"": 2,
""x_coordinate"": 97,
""y_coordinate"": 17,
""demo_start_time"": 143,
""demo_end_time"": 384
},
{
""location_id"": 3,
""x_coordinate"": 9,
""y_coordinate"": 0,
""demo_start_time"": 239,
""demo_end_time"": 469
},
{
""location_id"": 4,
""x_coordinate"": 0,
""y_coordinate"": 38,
""demo_start_time"": 179,
""demo_end_time"": 445
},
{
""location_id"": 5,
""x_coordinate"": 3,
""y_coordinate"": 48,
""demo_start_time"": 14,
""demo_end_time"": 232
},
{
""location_id"": 6,
""x_coordinate"": 31,
""y_coordinate"": 77,
""demo_start_time"": 276,
""demo_end_time"": 557
},
{
""location_id"": 7,
""x_coordinate"": 42,
""y_coordinate"": 57,
""demo_start_time"": 198,
""demo_end_time"": 444
},
{
""location_id"": 8,
""x_coordinate"": 65,
""y_coordinate"": 48,
""demo_start_time"": 41,
""demo_end_time"": 278
},
{
""location_id"": 9,
""x_coordinate"": 74,
""y_coordinate"": 57,
""demo_start_time"": 206,
""demo_end_time"": 424
},
{
""location_id"": 10,
""x_coordinate"": 100,
""y_coordinate"": 77,
""demo_start_time"": 104,
""demo_end_time"": 335
},
{
""location_id"": 11,
""x_coordinate"": 13,
""y_coordinate"": 100,
""demo_start_time"": 7,
""demo_end_time"": 233
}
],
""office_node_id"": 1
}
Also, if you want to give me the route in a tidy, machine-friendly form, here's the little JSON shape I expect — just a simple list that starts and ends at the office.
{
""solution"": [office_id, retailer_id, ..., office_id]
}
Think of this as a form: ""solution"" is the ordered tour (start at the office, visit each retailer once, come back to the office). The placeholders here stand in for the exact IDs from the instance — you’ll replace them with the real identifiers when you send the actual route. This snippet is only a sketch of the expected shape, not the final answer.
Please use the identifiers exactly as they appear in the instance input — do not rename them and do not 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': [[4, 34], [97, 17], [9, 0], [0, 38], [3, 48], [31, 77], [42, 57], [65, 48], [74, 57], [100, 77], [13, 100]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [143, 384], [239, 469], [179, 445], [14, 232], [276, 557], [198, 444], [41, 278], [206, 424], [104, 335], [7, 233]], 'tour_length': 446.6815357093644, 'objective': 446.6815357093644}","[0, 4, 10, 9, 1, 8, 7, 6, 5, 3, 2, 0]",446.6815357093644,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 1, 'x': 4, 'y': 34, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 97, 'y': 17, 'tw_start': 143, 'tw_end': 384}, {'id': 3, 'x': 9, 'y': 0, 'tw_start': 239, 'tw_end': 469}, {'id': 4, 'x': 0, 'y': 38, 'tw_start': 179, 'tw_end': 445}, {'id': 5, 'x': 3, 'y': 48, 'tw_start': 14, 'tw_end': 232}, {'id': 6, 'x': 31, 'y': 77, 'tw_start': 276, 'tw_end': 557}, {'id': 7, 'x': 42, 'y': 57, 'tw_start': 198, 'tw_end': 444}, {'id': 8, 'x': 65, 'y': 48, 'tw_start': 41, 'tw_end': 278}, {'id': 9, 'x': 74, 'y': 57, 'tw_start': 206, 'tw_end': 424}, {'id': 10, 'x': 100, 'y': 77, 'tw_start': 104, 'tw_end': 335}, {'id': 11, 'x': 13, 'y': 100, 'tw_start': 7, 'tw_end': 233}], 'depot': 1, 'objective': 446.6815357093644}","[1, 5, 11, 10, 2, 9, 8, 7, 6, 4, 3, 1]",25,json,1
TSPTW,TSPTW,"Recently the branch started planning mobile visits to neighborhood centers, and the challenge is to plan one loop that starts and finishes at the branch, drops by every center once while respecting their allowed visit times, and keeps the driving as low as possible. To tell which loop is best, add up the distance of every leg of the trip — the lowest total distance is the winner. Visits can be delayed by waiting if arriving early, but each center must be visited exactly once. The concrete details are given below.
# total_stops_including_branch=11
# branch_node_id=A
# time windows are listed per node in the table
location_node_id,map_x_coordinate,map_y_coordinate,visit_window_start,visit_window_end
A,100,0,0,1067
B,70,10,82,307
C,87,79,46,326
D,71,100,230,490
E,61,44,306,548
F,69,47,33,279
G,35,10,227,494
H,25,71,167,373
I,1,74,110,339
J,6,49,250,499
K,0,8,138,427
When you send the route back, just use a tiny JSON layout so it's easy to read and plug into the planner. For example, something in the shape below works nicely:
{
""solution"": [branch_id, center_id, ..., branch_id]
}
""solution"" is the ordered loop: the first and last entry are the branch, and everything in between is a center in the order you'll visit them. Think of it as a simple form to fill out — it's just the shape we expect, not the real route itself.
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': [[100, 0], [70, 10], [87, 79], [71, 100], [61, 44], [69, 47], [35, 10], [25, 71], [1, 74], [6, 49], [0, 8]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [82, 307], [46, 326], [230, 490], [306, 548], [33, 279], [227, 494], [167, 373], [110, 339], [250, 499], [138, 427]], 'tour_length': 413.9042625232761, 'objective': 413.9042625232761}","[0, 1, 5, 2, 3, 7, 8, 9, 10, 6, 4, 0]",413.9042625232761,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 100, 'y': 0, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 70, 'y': 10, 'tw_start': 82, 'tw_end': 307}, {'id': 'C', 'x': 87, 'y': 79, 'tw_start': 46, 'tw_end': 326}, {'id': 'D', 'x': 71, 'y': 100, 'tw_start': 230, 'tw_end': 490}, {'id': 'E', 'x': 61, 'y': 44, 'tw_start': 306, 'tw_end': 548}, {'id': 'F', 'x': 69, 'y': 47, 'tw_start': 33, 'tw_end': 279}, {'id': 'G', 'x': 35, 'y': 10, 'tw_start': 227, 'tw_end': 494}, {'id': 'H', 'x': 25, 'y': 71, 'tw_start': 167, 'tw_end': 373}, {'id': 'I', 'x': 1, 'y': 74, 'tw_start': 110, 'tw_end': 339}, {'id': 'J', 'x': 6, 'y': 49, 'tw_start': 250, 'tw_end': 499}, {'id': 'K', 'x': 0, 'y': 8, 'tw_start': 138, 'tw_end': 427}], 'depot': 'A', 'objective': 413.9042625232761}","['A', 'B', 'F', 'C', 'D', 'H', 'I', 'J', 'K', 'G', 'E', 'A']",26,csv,names
TSPTW,TSPTW,"We have a single truck that must leave the farm, visit every market stall one time to set up during its assigned opening window, and then return to the farm at the end. The decision is simply the order of visits — a good order means the total miles driven (add up all the legs: farm to first, between stalls, and back to farm) is as small as possible. Every stall must be visited exactly once within its time slot, and standing by until a stall’s setup window starts is allowed. The concrete details are listed below.
{
""total_locations_including_farm"": 11,
""nodes"": [
{
""location_id"": ""A"",
""x_coordinate"": 11,
""y_coordinate"": 0,
""setup_window_start"": 0,
""setup_window_end"": 1067
},
{
""location_id"": ""B"",
""x_coordinate"": 97,
""y_coordinate"": 21,
""setup_window_start"": 235,
""setup_window_end"": 452
},
{
""location_id"": ""C"",
""x_coordinate"": 100,
""y_coordinate"": 77,
""setup_window_start"": 39,
""setup_window_end"": 248
},
{
""location_id"": ""D"",
""x_coordinate"": 81,
""y_coordinate"": 78,
""setup_window_start"": 95,
""setup_window_end"": 305
},
{
""location_id"": ""E"",
""x_coordinate"": 66,
""y_coordinate"": 28,
""setup_window_start"": 72,
""setup_window_end"": 294
},
{
""location_id"": ""F"",
""x_coordinate"": 41,
""y_coordinate"": 12,
""setup_window_start"": 67,
""setup_window_end"": 348
},
{
""location_id"": ""G"",
""x_coordinate"": 34,
""y_coordinate"": 60,
""setup_window_start"": 31,
""setup_window_end"": 276
},
{
""location_id"": ""H"",
""x_coordinate"": 57,
""y_coordinate"": 99,
""setup_window_start"": 159,
""setup_window_end"": 448
},
{
""location_id"": ""I"",
""x_coordinate"": 57,
""y_coordinate"": 100,
""setup_window_start"": 43,
""setup_window_end"": 276
},
{
""location_id"": ""J"",
""x_coordinate"": 3,
""y_coordinate"": 79,
""setup_window_start"": 376,
""setup_window_end"": 654
},
{
""location_id"": ""K"",
""x_coordinate"": 0,
""y_coordinate"": 19,
""setup_window_start"": 317,
""setup_window_end"": 536
}
],
""farm_depot_id"": ""A""
}
You can return the chosen route in a tiny JSON object like this — nothing fancy, just the order of stops so I know which stall you hit when and that you start and end at the farm:
{
""solution"": [farm_id, stall_id, ..., farm_id]
}
Just so it’s clear: ""solution"" holds the list of stops in order, beginning and ending with the farm. Each placeholder there stands for the identifier of the farm or a stall (the ""..."" just means all the other stalls in between). This is only a sketch of the shape I expect — don’t treat these placeholders as your actual answer.
Please 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': [[11, 0], [97, 21], [100, 77], [81, 78], [66, 28], [41, 12], [34, 60], [57, 99], [57, 100], [3, 79], [0, 19]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [235, 452], [39, 248], [95, 305], [72, 294], [67, 348], [31, 276], [159, 448], [43, 276], [376, 654], [317, 536]], 'tour_length': 453.67169279809957, 'objective': 453.67169279809957}","[0, 5, 4, 6, 7, 8, 3, 2, 1, 9, 10, 0]",453.67169279809957,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 11, 'y': 0, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 97, 'y': 21, 'tw_start': 235, 'tw_end': 452}, {'id': 'C', 'x': 100, 'y': 77, 'tw_start': 39, 'tw_end': 248}, {'id': 'D', 'x': 81, 'y': 78, 'tw_start': 95, 'tw_end': 305}, {'id': 'E', 'x': 66, 'y': 28, 'tw_start': 72, 'tw_end': 294}, {'id': 'F', 'x': 41, 'y': 12, 'tw_start': 67, 'tw_end': 348}, {'id': 'G', 'x': 34, 'y': 60, 'tw_start': 31, 'tw_end': 276}, {'id': 'H', 'x': 57, 'y': 99, 'tw_start': 159, 'tw_end': 448}, {'id': 'I', 'x': 57, 'y': 100, 'tw_start': 43, 'tw_end': 276}, {'id': 'J', 'x': 3, 'y': 79, 'tw_start': 376, 'tw_end': 654}, {'id': 'K', 'x': 0, 'y': 19, 'tw_start': 317, 'tw_end': 536}], 'depot': 'A', 'objective': 453.67169279809957}","['A', 'F', 'E', 'G', 'H', 'I', 'D', 'C', 'B', 'J', 'K', 'A']",27,json,names
TSPTW,TSPTW,"Back at headquarters the morning plan is simple: the inspector must start here, knock out inspections at all sites exactly once within each site’s specified inspection window (it’s okay to wait until the slot opens), and return here at the end of the run. Routes are judged by how much driving they require — add up each leg from one place to the next, including returning to HQ, and the route with the smallest total distance wins. The full details for each site and its time window are shown below.
# total_locations_count=13
# hq_node_id=A
# time windows are listed per node in the table
site_id,x_coord,y_coord,inspection_window_open,inspection_window_close
A,34,100,0,1067
B,19,9,294,546
C,73,64,182,416
D,26,11,135,419
E,1,83,322,609
F,86,52,48,313
G,100,79,364,575
H,66,63,25,291
I,90,76,222,498
J,80,0,54,325
K,21,31,78,288
L,0,63,63,336
M,70,66,258,502
Oh, and when you send the route back, just use a little JSON sketch like this so it's easy to parse:
{
""solution"": [hq_id, site_id, ..., hq_id]
}
Think of that as a simple form: the solution array is the visit order — start at HQ, list every site once in the order you’ll visit them, and finish back at HQ. It’s just the shape I expect, not the actual route.
Please make sure to 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': [[34, 100], [19, 9], [73, 64], [26, 11], [1, 83], [86, 52], [100, 79], [66, 63], [90, 76], [80, 0], [21, 31], [0, 63], [70, 66]], 'depot': 0, 'num_nodes': 13, 'time_windows': [[0, 1067], [294, 546], [182, 416], [135, 419], [322, 609], [48, 313], [364, 575], [25, 291], [222, 498], [54, 325], [78, 288], [63, 336], [258, 502]], 'tour_length': 498.46455416197995, 'objective': 498.46455416197995}","[0, 11, 10, 3, 9, 5, 7, 12, 8, 6, 2, 1, 4, 0]",498.46455416197995,"{'problem_type': 'TSPTW', 'num_nodes': 13, 'nodes': [{'id': 'A', 'x': 34, 'y': 100, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 19, 'y': 9, 'tw_start': 294, 'tw_end': 546}, {'id': 'C', 'x': 73, 'y': 64, 'tw_start': 182, 'tw_end': 416}, {'id': 'D', 'x': 26, 'y': 11, 'tw_start': 135, 'tw_end': 419}, {'id': 'E', 'x': 1, 'y': 83, 'tw_start': 322, 'tw_end': 609}, {'id': 'F', 'x': 86, 'y': 52, 'tw_start': 48, 'tw_end': 313}, {'id': 'G', 'x': 100, 'y': 79, 'tw_start': 364, 'tw_end': 575}, {'id': 'H', 'x': 66, 'y': 63, 'tw_start': 25, 'tw_end': 291}, {'id': 'I', 'x': 90, 'y': 76, 'tw_start': 222, 'tw_end': 498}, {'id': 'J', 'x': 80, 'y': 0, 'tw_start': 54, 'tw_end': 325}, {'id': 'K', 'x': 21, 'y': 31, 'tw_start': 78, 'tw_end': 288}, {'id': 'L', 'x': 0, 'y': 63, 'tw_start': 63, 'tw_end': 336}, {'id': 'M', 'x': 70, 'y': 66, 'tw_start': 258, 'tw_end': 502}], 'depot': 'A', 'objective': 498.46455416197995}","['A', 'L', 'K', 'D', 'J', 'F', 'H', 'M', 'I', 'G', 'C', 'B', 'E', 'A']",28,csv,names
TSPTW,TSPTW,"Recently the gardening company had to sort out a day’s work — a team leaves the depot, must tend each customer’s garden one time during that customer’s scheduled window, and then return to the depot. The job is to pick the sequence of visits so the total driving is as small as possible: for each plan, sum the lengths of the legs between stops (and back home) and choose the smallest total. Every client must be visited exactly once and time windows must be respected; arriving early can be handled by waiting. The full list of appointments and distances is shown below.
They must handle 14 locations in total, with the depot at 1.
| location_id | x_coordinate | y_coordinate | time_window_start | time_window_end |
|---|---|---|---|---|
| 1 | 0 | 100 | 0 | 1067 |
| 2 | 22 | 16 | 139 | 418 |
| 3 | 41 | 29 | 152 | 425 |
| 4 | 45 | 58 | 170 | 400 |
| 5 | 76 | 16 | 179 | 402 |
| 6 | 69 | 100 | 290 | 532 |
| 7 | 76 | 100 | 90 | 371 |
| 8 | 100 | 81 | 148 | 395 |
| 9 | 95 | 90 | 351 | 606 |
| 10 | 83 | 36 | 45 | 330 |
| 11 | 83 | 26 | 243 | 470 |
| 12 | 88 | 7 | 54 | 325 |
| 13 | 45 | 0 | 240 | 486 |
| 14 | 31 | 100 | 346 | 617 |
Every plan must visit all 14 locations and return to 1.
When you're ready to give the planned route, just hand it back in this simple JSON layout so it's easy to read:
{
""solution"": [""depot_id"", ""location_id"", ""..."", ""depot_id""]
}
This just means: ""solution"" is the sequence of stops — start at the depot, list each customer once in the order they'll be visited, and end at the depot. The names in the example are placeholders to show the shape; they're not the actual labels from the instance.
The JSON above is only a sketch of the expected shape, not the final answer.
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': [[0, 100], [22, 16], [41, 29], [45, 58], [76, 16], [69, 100], [76, 100], [100, 81], [95, 90], [83, 36], [83, 26], [88, 7], [45, 0], [31, 100]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [139, 418], [152, 425], [170, 400], [179, 402], [290, 532], [90, 371], [148, 395], [351, 606], [45, 330], [243, 470], [54, 325], [240, 486], [346, 617]], 'tour_length': 443.30454556783945, 'objective': 443.30454556783945}","[0, 6, 3, 2, 1, 12, 4, 11, 10, 9, 7, 8, 5, 13, 0]",443.30454556783945,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 1, 'x': 0, 'y': 100, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 22, 'y': 16, 'tw_start': 139, 'tw_end': 418}, {'id': 3, 'x': 41, 'y': 29, 'tw_start': 152, 'tw_end': 425}, {'id': 4, 'x': 45, 'y': 58, 'tw_start': 170, 'tw_end': 400}, {'id': 5, 'x': 76, 'y': 16, 'tw_start': 179, 'tw_end': 402}, {'id': 6, 'x': 69, 'y': 100, 'tw_start': 290, 'tw_end': 532}, {'id': 7, 'x': 76, 'y': 100, 'tw_start': 90, 'tw_end': 371}, {'id': 8, 'x': 100, 'y': 81, 'tw_start': 148, 'tw_end': 395}, {'id': 9, 'x': 95, 'y': 90, 'tw_start': 351, 'tw_end': 606}, {'id': 10, 'x': 83, 'y': 36, 'tw_start': 45, 'tw_end': 330}, {'id': 11, 'x': 83, 'y': 26, 'tw_start': 243, 'tw_end': 470}, {'id': 12, 'x': 88, 'y': 7, 'tw_start': 54, 'tw_end': 325}, {'id': 13, 'x': 45, 'y': 0, 'tw_start': 240, 'tw_end': 486}, {'id': 14, 'x': 31, 'y': 100, 'tw_start': 346, 'tw_end': 617}], 'depot': 1, 'objective': 443.30454556783945}","[1, 7, 4, 3, 2, 13, 5, 12, 11, 10, 8, 9, 6, 14, 1]",29,markdown_table,1
TSPTW,TSPTW,"Someone in charge of the ice cream truck schedule has to pick the order of stops so the day starts and ends at the truck yard, every stop gets visited exactly once during its allotted time, and no place is skipped or visited twice. The goal is to keep the total driving to a minimum: tally the distance between each consecutive stop in the route (and include the drive back to base) and prefer the route with the smallest total, with waiting allowed if reaching a stop early. The specific stops, time windows, and distances appear below.
# total_stops_including_depot=15
# truck_yard_id=0
# time windows are listed per node in the table
stop_id,map_x,map_y,active_start_time,active_end_time
0,2,88,0,1067
1,32,100,70,352
2,100,74,226,459
3,81,5,179,465
4,46,2,59,310
5,48,93,196,449
6,43,26,7,285
7,13,0,361,610
8,29,58,270,553
9,83,24,274,483
10,100,6,223,476
11,0,66,164,429
12,22,86,362,646
13,58,60,174,379
14,43,12,382,657
Oh, and when you send the route back, you can just use this simple JSON layout:
{
""solution"": [depot_id, location_id, ..., depot_id]
}
Think of ""solution"" as the ordered list of stops: start at the depot, follow the stops in order, and finish back at the depot. The depot_id and location_id bits are placeholders for the actual stop identifiers from the instance. This is just a sketch of the shape I need — not the real route.
Please use the identifiers exactly as they appear in the instance input — do not rename them or introduce 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': [[2, 88], [32, 100], [100, 74], [81, 5], [46, 2], [48, 93], [43, 26], [13, 0], [29, 58], [83, 24], [100, 6], [0, 66], [22, 86], [58, 60], [43, 12]], 'depot': 0, 'num_nodes': 15, 'time_windows': [[0, 1067], [70, 352], [226, 459], [179, 465], [59, 310], [196, 449], [7, 285], [361, 610], [270, 553], [274, 483], [223, 476], [164, 429], [362, 646], [174, 379], [382, 657]], 'tour_length': 596.9162363860437, 'objective': 596.9162363860437}","[0, 6, 4, 11, 1, 5, 13, 2, 9, 10, 3, 14, 7, 8, 12, 0]",596.9162363860437,"{'problem_type': 'TSPTW', 'num_nodes': 15, 'nodes': [{'id': 0, 'x': 2, 'y': 88, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 32, 'y': 100, 'tw_start': 70, 'tw_end': 352}, {'id': 2, 'x': 100, 'y': 74, 'tw_start': 226, 'tw_end': 459}, {'id': 3, 'x': 81, 'y': 5, 'tw_start': 179, 'tw_end': 465}, {'id': 4, 'x': 46, 'y': 2, 'tw_start': 59, 'tw_end': 310}, {'id': 5, 'x': 48, 'y': 93, 'tw_start': 196, 'tw_end': 449}, {'id': 6, 'x': 43, 'y': 26, 'tw_start': 7, 'tw_end': 285}, {'id': 7, 'x': 13, 'y': 0, 'tw_start': 361, 'tw_end': 610}, {'id': 8, 'x': 29, 'y': 58, 'tw_start': 270, 'tw_end': 553}, {'id': 9, 'x': 83, 'y': 24, 'tw_start': 274, 'tw_end': 483}, {'id': 10, 'x': 100, 'y': 6, 'tw_start': 223, 'tw_end': 476}, {'id': 11, 'x': 0, 'y': 66, 'tw_start': 164, 'tw_end': 429}, {'id': 12, 'x': 22, 'y': 86, 'tw_start': 362, 'tw_end': 646}, {'id': 13, 'x': 58, 'y': 60, 'tw_start': 174, 'tw_end': 379}, {'id': 14, 'x': 43, 'y': 12, 'tw_start': 382, 'tw_end': 657}], 'depot': 0, 'objective': 596.9162363860437}","[0, 6, 4, 11, 1, 5, 13, 2, 9, 10, 3, 14, 7, 8, 12, 0]",30,csv,0
TSPTW,TSPTW,"On a typical morning the mobile lab team has to craft a route: leave the lab, swing by each clinic once during its designated pickup time (it’s allowed to wait if arriving too early), and return to base at the end. The decision is just the order of stops, and the route that’s better is the one that minimizes how far the van drives overall — total distance is the sum of each leg from one stop to the next, plus the journey back to the lab. No stops can be skipped or repeated, and every pickup must fall inside its window. The specific stops and time windows are listed below.
There are 15 stops in total (including the lab), with the lab depot labeled A.
Stop A located at (11, 83), pickup allowed between 0 and 1067.
Stop B located at (0, 100), pickup allowed between 48 and 331.
Stop C located at (34, 77), pickup allowed between 337 and 581.
Stop D located at (41, 55), pickup allowed between 229 and 462.
Stop E located at (71, 35), pickup allowed between 21 and 247.
Stop F located at (77, 34), pickup allowed between 311 and 505.
Stop G located at (61, 29), pickup allowed between 129 and 362.
Stop H located at (86, 28), pickup allowed between 208 and 491.
Stop I located at (87, 28), pickup allowed between 134 and 362.
Stop J located at (48, 25), pickup allowed between 286 and 524.
Stop K located at (61, 21), pickup allowed between 87 and 325.
Stop L located at (64, 14), pickup allowed between 54 and 265.
Stop M located at (78, 10), pickup allowed between 193 and 428.
Stop N located at (72, 0), pickup allowed between 354 and 584.
Stop O located at (100, 10), pickup allowed between 225 and 480.
Use these entries to choose an order that visits every stop once and returns to A, while respecting all pickup windows.
When you send back the route, just use this simple JSON shape so it's easy to read and parse:
{
""solution"": [lab_id, clinic_id, ..., lab_id]
}
""solution"" is the ordered list of stops — start at the lab (first entry), visit each clinic once in the order shown, and come back to the lab (last entry). The names in the example above are just placeholders to show the shape; replace them with the actual IDs from the instance. This JSON is only a sketch of the expected shape, not the final answer.
Please 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': [[11, 83], [0, 100], [34, 77], [41, 55], [71, 35], [77, 34], [61, 29], [86, 28], [87, 28], [48, 25], [61, 21], [64, 14], [78, 10], [72, 0], [100, 10]], 'depot': 0, 'num_nodes': 15, 'time_windows': [[0, 1067], [48, 331], [337, 581], [229, 462], [21, 247], [311, 505], [129, 362], [208, 491], [134, 362], [286, 524], [87, 325], [54, 265], [193, 428], [354, 584], [225, 480]], 'tour_length': 337.6884642196724, 'objective': 337.6884642196724}","[0, 1, 6, 10, 11, 4, 5, 7, 8, 14, 12, 13, 9, 3, 2, 0]",337.6884642196724,"{'problem_type': 'TSPTW', 'num_nodes': 15, 'nodes': [{'id': 'A', 'x': 11, 'y': 83, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 0, 'y': 100, 'tw_start': 48, 'tw_end': 331}, {'id': 'C', 'x': 34, 'y': 77, 'tw_start': 337, 'tw_end': 581}, {'id': 'D', 'x': 41, 'y': 55, 'tw_start': 229, 'tw_end': 462}, {'id': 'E', 'x': 71, 'y': 35, 'tw_start': 21, 'tw_end': 247}, {'id': 'F', 'x': 77, 'y': 34, 'tw_start': 311, 'tw_end': 505}, {'id': 'G', 'x': 61, 'y': 29, 'tw_start': 129, 'tw_end': 362}, {'id': 'H', 'x': 86, 'y': 28, 'tw_start': 208, 'tw_end': 491}, {'id': 'I', 'x': 87, 'y': 28, 'tw_start': 134, 'tw_end': 362}, {'id': 'J', 'x': 48, 'y': 25, 'tw_start': 286, 'tw_end': 524}, {'id': 'K', 'x': 61, 'y': 21, 'tw_start': 87, 'tw_end': 325}, {'id': 'L', 'x': 64, 'y': 14, 'tw_start': 54, 'tw_end': 265}, {'id': 'M', 'x': 78, 'y': 10, 'tw_start': 193, 'tw_end': 428}, {'id': 'N', 'x': 72, 'y': 0, 'tw_start': 354, 'tw_end': 584}, {'id': 'O', 'x': 100, 'y': 10, 'tw_start': 225, 'tw_end': 480}], 'depot': 'A', 'objective': 337.6884642196724}","['A', 'B', 'G', 'K', 'L', 'E', 'F', 'H', 'I', 'O', 'M', 'N', 'J', 'D', 'C', 'A']",31,nl,names
TSPTW,TSPTW,"Recently an agent told a story about a day packed with back-to-back viewings, each with a strict time window, and the need to start and finish at the brokerage. The decision was which order to follow so each flat is shown once at the right time (arriving early and waiting if necessary is okay) and the overall miles driven — calculated by adding every drive between stops, including the return — end up as low as possible. The exact appointments and addresses are listed below.
There were 14 stops in total, starting and ending at the brokerage office A.
Stop A at coordinates (0, 95) had a viewing window from 0 to 1067.
Stop B at coordinates (36, 51) had a viewing window from 5 to 263.
Stop C at coordinates (100, 100) had a viewing window from 69 to 356.
Stop D at coordinates (100, 92) had a viewing window from 57 to 291.
Stop E at coordinates (100, 82) had a viewing window from 33 to 323.
Stop F at coordinates (100, 74) had a viewing window from 194 to 446.
Stop G at coordinates (100, 67) had a viewing window from 26 to 292.
Stop H at coordinates (100, 64) had a viewing window from 81 to 362.
Stop I at coordinates (85, 64) had a viewing window from 79 to 292.
Stop J at coordinates (45, 5) had a viewing window from 14 to 253.
Stop K at coordinates (53, 21) had a viewing window from 219 to 419.
Stop L at coordinates (49, 36) had a viewing window from 300 to 538.
Stop M at coordinates (19, 0) had a viewing window from 203 to 440.
Stop N at coordinates (28, 46) had a viewing window from 155 to 403.
The agent then planned a visiting order that met each viewing window while keeping the total miles driven as low as possible.
Oh, and when you hand back the route, a little JSON like this is perfect — just a tiny, predictable shape so it's easy to check automatically:
{
""solution"": [brokerage_id, flat_id, ..., brokerage_id]
}
This just shows the shape I need: ""solution"" is the ordered list of stops (start at the brokerage, visit every flat once in the listed order, and return to the brokerage). The placeholder names above are only a sketch of the format — don’t treat them as the real IDs.
Please make sure to use the exact identifiers from the instance input (no renaming, 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, 95], [36, 51], [100, 100], [100, 92], [100, 82], [100, 74], [100, 67], [100, 64], [85, 64], [45, 5], [53, 21], [49, 36], [19, 0], [28, 46]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [5, 263], [69, 356], [57, 291], [33, 323], [194, 446], [26, 292], [81, 362], [79, 292], [14, 253], [219, 419], [300, 538], [203, 440], [155, 403]], 'tour_length': 490.34011769459596, 'objective': 490.34011769459596}","[0, 9, 13, 1, 8, 7, 6, 5, 4, 3, 2, 11, 10, 12, 0]",490.34011769459596,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 0, 'y': 95, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 36, 'y': 51, 'tw_start': 5, 'tw_end': 263}, {'id': 'C', 'x': 100, 'y': 100, 'tw_start': 69, 'tw_end': 356}, {'id': 'D', 'x': 100, 'y': 92, 'tw_start': 57, 'tw_end': 291}, {'id': 'E', 'x': 100, 'y': 82, 'tw_start': 33, 'tw_end': 323}, {'id': 'F', 'x': 100, 'y': 74, 'tw_start': 194, 'tw_end': 446}, {'id': 'G', 'x': 100, 'y': 67, 'tw_start': 26, 'tw_end': 292}, {'id': 'H', 'x': 100, 'y': 64, 'tw_start': 81, 'tw_end': 362}, {'id': 'I', 'x': 85, 'y': 64, 'tw_start': 79, 'tw_end': 292}, {'id': 'J', 'x': 45, 'y': 5, 'tw_start': 14, 'tw_end': 253}, {'id': 'K', 'x': 53, 'y': 21, 'tw_start': 219, 'tw_end': 419}, {'id': 'L', 'x': 49, 'y': 36, 'tw_start': 300, 'tw_end': 538}, {'id': 'M', 'x': 19, 'y': 0, 'tw_start': 203, 'tw_end': 440}, {'id': 'N', 'x': 28, 'y': 46, 'tw_start': 155, 'tw_end': 403}], 'depot': 'A', 'objective': 490.34011769459596}","['A', 'J', 'N', 'B', 'I', 'H', 'G', 'F', 'E', 'D', 'C', 'L', 'K', 'M', 'A']",32,nl,names
TSPTW,TSPTW,"There’s a tuner with a van, a handful of schools, and a single-day route to sort out: begin at the workshop, visit every school once during its available lesson period, then return to the workshop. What makes one route nicer than another is how little driving it requires — the total distance comes from summing each leg of the trip — and arriving ahead of a lesson to wait is allowed if needed. The specific schools, their time windows, and distances appear below.
{
""total_locations_including_workshop"": 15,
""nodes"": [
{
""location_id"": 1,
""coord_x"": 95,
""coord_y"": 100,
""lesson_period_start"": 0,
""lesson_period_end"": 1067
},
{
""location_id"": 2,
""coord_x"": 27,
""coord_y"": 61,
""lesson_period_start"": 280,
""lesson_period_end"": 557
},
{
""location_id"": 3,
""coord_x"": 80,
""coord_y"": 57,
""lesson_period_start"": 322,
""lesson_period_end"": 554
},
{
""location_id"": 4,
""coord_x"": 43,
""coord_y"": 16,
""lesson_period_start"": 259,
""lesson_period_end"": 473
},
{
""location_id"": 5,
""coord_x"": 63,
""coord_y"": 67,
""lesson_period_start"": 113,
""lesson_period_end"": 394
},
{
""location_id"": 6,
""coord_x"": 14,
""coord_y"": 50,
""lesson_period_start"": 5,
""lesson_period_end"": 207
},
{
""location_id"": 7,
""coord_x"": 16,
""coord_y"": 16,
""lesson_period_start"": 80,
""lesson_period_end"": 277
},
{
""location_id"": 8,
""coord_x"": 36,
""coord_y"": 70,
""lesson_period_start"": 70,
""lesson_period_end"": 320
},
{
""location_id"": 9,
""coord_x"": 55,
""coord_y"": 56,
""lesson_period_start"": 163,
""lesson_period_end"": 444
},
{
""location_id"": 10,
""coord_x"": 100,
""coord_y"": 0,
""lesson_period_start"": 317,
""lesson_period_end"": 544
},
{
""location_id"": 11,
""coord_x"": 81,
""coord_y"": 8,
""lesson_period_start"": 100,
""lesson_period_end"": 331
},
{
""location_id"": 12,
""coord_x"": 34,
""coord_y"": 22,
""lesson_period_start"": 229,
""lesson_period_end"": 449
},
{
""location_id"": 13,
""coord_x"": 9,
""coord_y"": 81,
""lesson_period_start"": 242,
""lesson_period_end"": 475
},
{
""location_id"": 14,
""coord_x"": 89,
""coord_y"": 68,
""lesson_period_start"": 214,
""lesson_period_end"": 450
},
{
""location_id"": 15,
""coord_x"": 0,
""coord_y"": 100,
""lesson_period_start"": 114,
""lesson_period_end"": 400
}
],
""workshop_id"": 1
}
When you send back the route, just paste a tiny JSON snippet that looks like this — nice and simple:
{
""solution"": [workshop_id, school_id, ..., workshop_id]
}
Here ""solution"" should be the tour: start at the workshop, list each school in the order you'll visit them, and finish back at the workshop. The placeholders (workshop_id and school_id) are just that — placeholders showing the shape I expect, not the real labels.
Please use the exact identifiers from the problem input when you fill this in — 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': [[95, 100], [27, 61], [80, 57], [43, 16], [63, 67], [14, 50], [16, 16], [36, 70], [55, 56], [100, 0], [81, 8], [34, 22], [9, 81], [89, 68], [0, 100]], 'depot': 0, 'num_nodes': 15, 'time_windows': [[0, 1067], [280, 557], [322, 554], [259, 473], [113, 394], [5, 207], [80, 277], [70, 320], [163, 444], [317, 544], [100, 331], [229, 449], [242, 475], [214, 450], [114, 400]], 'tour_length': 607.7154773387698, 'objective': 607.7154773387698}","[0, 10, 6, 5, 14, 12, 1, 7, 4, 13, 2, 8, 11, 3, 9, 0]",607.7154773387698,"{'problem_type': 'TSPTW', 'num_nodes': 15, 'nodes': [{'id': 1, 'x': 95, 'y': 100, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 27, 'y': 61, 'tw_start': 280, 'tw_end': 557}, {'id': 3, 'x': 80, 'y': 57, 'tw_start': 322, 'tw_end': 554}, {'id': 4, 'x': 43, 'y': 16, 'tw_start': 259, 'tw_end': 473}, {'id': 5, 'x': 63, 'y': 67, 'tw_start': 113, 'tw_end': 394}, {'id': 6, 'x': 14, 'y': 50, 'tw_start': 5, 'tw_end': 207}, {'id': 7, 'x': 16, 'y': 16, 'tw_start': 80, 'tw_end': 277}, {'id': 8, 'x': 36, 'y': 70, 'tw_start': 70, 'tw_end': 320}, {'id': 9, 'x': 55, 'y': 56, 'tw_start': 163, 'tw_end': 444}, {'id': 10, 'x': 100, 'y': 0, 'tw_start': 317, 'tw_end': 544}, {'id': 11, 'x': 81, 'y': 8, 'tw_start': 100, 'tw_end': 331}, {'id': 12, 'x': 34, 'y': 22, 'tw_start': 229, 'tw_end': 449}, {'id': 13, 'x': 9, 'y': 81, 'tw_start': 242, 'tw_end': 475}, {'id': 14, 'x': 89, 'y': 68, 'tw_start': 214, 'tw_end': 450}, {'id': 15, 'x': 0, 'y': 100, 'tw_start': 114, 'tw_end': 400}], 'depot': 1, 'objective': 607.7154773387698}","[1, 11, 7, 6, 15, 13, 2, 8, 5, 14, 3, 9, 12, 4, 10, 1]",33,json,1
TSPTW,TSPTW,"Out in the field, planning a tech’s day looks like this: pick a route that leaves the depot, hits every customer one time during the slot they were promised, and heads back to the depot at the end. What counts as a good route is simple — the one with the smallest sum of miles driven — and that sum comes from adding the distances between each pair of consecutive stops in the route plus the trip out and the trip back. Arriving before a window opens and waiting is allowed, but no customer can be missed or visited twice. The concrete route details and appointment times are shown below.
Below are the 14 locations (depot 1 included):
Stop 1 at coordinates (25, 0) — arrive between 0 and 1067.
Stop 2 at coordinates (0, 33) — arrive between 296 and 503.
Stop 3 at coordinates (86, 27) — arrive between 336 and 578.
Stop 4 at coordinates (15, 43) — arrive between 347 and 618.
Stop 5 at coordinates (42, 47) — arrive between 164 and 361.
Stop 6 at coordinates (100, 49) — arrive between 104 and 350.
Stop 7 at coordinates (3, 61) — arrive between 245 and 464.
Stop 8 at coordinates (99, 58) — arrive between 54 and 329.
Stop 9 at coordinates (58, 71) — arrive between 381 and 626.
Stop 10 at coordinates (70, 69) — arrive between 66 and 287.
Stop 11 at coordinates (53, 77) — arrive between 7 and 289.
Stop 12 at coordinates (44, 95) — arrive between 45 and 295.
Stop 13 at coordinates (59, 100) — arrive between 106 and 354.
Stop 14 at coordinates (70, 97) — arrive between 252 and 527.
Visit every one of the 14 stops exactly once, starting and ending at 1.
And hey — when you send the route back, please use a tiny JSON shape so it's easy to read and plug in. Something like this:
{
""solution"": [depot_id, location_id, ..., depot_id]
}
This little block just means: put the stops in order inside ""solution"", starting at the depot and finishing at the depot, with every customer listed exactly once. It's just a quick sketch of the shape I need, not the real answer itself.
Please don’t rename any of the identifiers from the instance input — use them exactly as given, 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': [[25, 0], [0, 33], [86, 27], [15, 43], [42, 47], [100, 49], [3, 61], [99, 58], [58, 71], [70, 69], [53, 77], [44, 95], [59, 100], [70, 97]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [296, 503], [336, 578], [347, 618], [164, 361], [104, 350], [245, 464], [54, 329], [381, 626], [66, 287], [7, 289], [45, 295], [106, 354], [252, 527]], 'tour_length': 412.5360263607499, 'objective': 412.5360263607499}","[0, 4, 10, 11, 12, 13, 9, 7, 5, 2, 8, 6, 3, 1, 0]",412.5360263607499,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 1, 'x': 25, 'y': 0, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 0, 'y': 33, 'tw_start': 296, 'tw_end': 503}, {'id': 3, 'x': 86, 'y': 27, 'tw_start': 336, 'tw_end': 578}, {'id': 4, 'x': 15, 'y': 43, 'tw_start': 347, 'tw_end': 618}, {'id': 5, 'x': 42, 'y': 47, 'tw_start': 164, 'tw_end': 361}, {'id': 6, 'x': 100, 'y': 49, 'tw_start': 104, 'tw_end': 350}, {'id': 7, 'x': 3, 'y': 61, 'tw_start': 245, 'tw_end': 464}, {'id': 8, 'x': 99, 'y': 58, 'tw_start': 54, 'tw_end': 329}, {'id': 9, 'x': 58, 'y': 71, 'tw_start': 381, 'tw_end': 626}, {'id': 10, 'x': 70, 'y': 69, 'tw_start': 66, 'tw_end': 287}, {'id': 11, 'x': 53, 'y': 77, 'tw_start': 7, 'tw_end': 289}, {'id': 12, 'x': 44, 'y': 95, 'tw_start': 45, 'tw_end': 295}, {'id': 13, 'x': 59, 'y': 100, 'tw_start': 106, 'tw_end': 354}, {'id': 14, 'x': 70, 'y': 97, 'tw_start': 252, 'tw_end': 527}], 'depot': 1, 'objective': 412.5360263607499}","[1, 5, 11, 12, 13, 14, 10, 8, 6, 3, 9, 7, 4, 2, 1]",34,nl,1
TSPTW,TSPTW,"We’ve got a vintage-car rally that starts at the clubhouse, must call at each museum and landmark exactly one time, and then finishes back at the clubhouse. The crew has to decide the visiting order, making sure each stop is reached during its hours (waiting is allowed if they get there early). What makes one visiting order better than another is simply how many miles the cars end up doing — total miles are found by adding every segment between consecutive stops, including the return — and the goal is the route with the smallest total. The concrete stops, hours and distances appear below.
There are 14 locations in total, with the clubhouse at A.
| stop_id | map_x_coordinate | map_y_coordinate | opening_time | closing_time |
|---|---|---|---|---|
| A | 29 | 38 | 0 | 1067 |
| B | 54 | 100 | 80 | 275 |
| C | 40 | 48 | 53 | 334 |
| D | 73 | 76 | 339 | 591 |
| E | 34 | 97 | 233 | 491 |
| F | 67 | 23 | 68 | 350 |
| G | 40 | 41 | 162 | 393 |
| H | 14 | 1 | 201 | 399 |
| I | 55 | 47 | 64 | 330 |
| J | 83 | 70 | 32 | 284 |
| K | 71 | 97 | 95 | 326 |
| L | 100 | 76 | 112 | 340 |
| M | 14 | 72 | 278 | 501 |
| N | 0 | 0 | 219 | 459 |
We’ll use these entries to plan the shortest route that starts and ends at A while visiting all 14 stops within their hours.
Also, when you send back the chosen route, please use this simple JSON layout so it's easy to read and feed into whatever's checking the rally results:
{
""solution"": [""clubhouse_id"", ""museum_id"", ..., ""clubhouse_id""]
}
This just says: ""solution"" is the tour as an ordered list — start at the clubhouse, list each stop in visiting order, and finish back at the clubhouse. The quoted names in the array are placeholders: swap them for the exact identifiers from the instance when you give the real route. It's just a sketch of the shape I need, not the final answer itself.
Please use the identifiers exactly as they appear in the instance input — no renaming and no invented 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': [[29, 38], [54, 100], [40, 48], [73, 76], [34, 97], [67, 23], [40, 41], [14, 1], [55, 47], [83, 70], [71, 97], [100, 76], [14, 72], [0, 0]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [80, 275], [53, 334], [339, 591], [233, 491], [68, 350], [162, 393], [201, 399], [64, 330], [32, 284], [95, 326], [112, 340], [278, 501], [219, 459]], 'tour_length': 491.7254682427593, 'objective': 491.7254682427593}","[0, 1, 10, 11, 9, 8, 2, 6, 13, 7, 5, 3, 4, 12, 0]",491.7254682427593,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 29, 'y': 38, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 54, 'y': 100, 'tw_start': 80, 'tw_end': 275}, {'id': 'C', 'x': 40, 'y': 48, 'tw_start': 53, 'tw_end': 334}, {'id': 'D', 'x': 73, 'y': 76, 'tw_start': 339, 'tw_end': 591}, {'id': 'E', 'x': 34, 'y': 97, 'tw_start': 233, 'tw_end': 491}, {'id': 'F', 'x': 67, 'y': 23, 'tw_start': 68, 'tw_end': 350}, {'id': 'G', 'x': 40, 'y': 41, 'tw_start': 162, 'tw_end': 393}, {'id': 'H', 'x': 14, 'y': 1, 'tw_start': 201, 'tw_end': 399}, {'id': 'I', 'x': 55, 'y': 47, 'tw_start': 64, 'tw_end': 330}, {'id': 'J', 'x': 83, 'y': 70, 'tw_start': 32, 'tw_end': 284}, {'id': 'K', 'x': 71, 'y': 97, 'tw_start': 95, 'tw_end': 326}, {'id': 'L', 'x': 100, 'y': 76, 'tw_start': 112, 'tw_end': 340}, {'id': 'M', 'x': 14, 'y': 72, 'tw_start': 278, 'tw_end': 501}, {'id': 'N', 'x': 0, 'y': 0, 'tw_start': 219, 'tw_end': 459}], 'depot': 'A', 'objective': 491.7254682427593}","['A', 'B', 'K', 'L', 'J', 'I', 'C', 'G', 'N', 'H', 'F', 'D', 'E', 'M', 'A']",35,markdown_table,names
TSPTW,TSPTW,"On a typical service day, the technician must leave the garage, go out to a collection of sites (each expecting service only during a given time window), and return home, making sure each site is visited exactly once and waiting if arriving early. The goal is to arrange the order and timing so the round trip uses as few miles as possible — the total distance being the sum of all legs between stops. The precise locations and their time slots are shown below.
The technician will consider 11 locations in total, with the garage identified as node A.
| location_id | map_x_coordinate | map_y_coordinate | service_time_window_start | service_time_window_end |
|---|---|---|---|---|
| A | 35 | 0 | 0 | 1067 |
| B | 31 | 8 | 257 | 542 |
| C | 100 | 11 | 284 | 499 |
| D | 9 | 21 | 12 | 231 |
| E | 49 | 21 | 230 | 429 |
| F | 23 | 23 | 192 | 444 |
| G | 12 | 31 | 129 | 398 |
| H | 65 | 38 | 41 | 242 |
| I | 0 | 45 | 282 | 524 |
| J | 94 | 99 | 267 | 503 |
| K | 66 | 100 | 95 | 369 |
The technician must schedule visits for these 11 locations (garage A) so the round trip covers as few miles as possible.
Also, when you send back the final route, just use a small JSON snippet like this so it's easy to parse:
{
""solution"": [garage_id, site_id, ..., garage_id]
}
Think of this as a little form: ""solution"" is the ordered list of stops — start at the garage, go visit each site once in the order shown, and then come back to the garage. The garage_id and site_id bits are just placeholders showing where the actual stop identifiers go. This block is only a sketch of the shape I want, not the actual route.
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': [[35, 0], [31, 8], [100, 11], [9, 21], [49, 21], [23, 23], [12, 31], [65, 38], [0, 45], [94, 99], [66, 100]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [257, 542], [284, 499], [12, 231], [230, 429], [192, 444], [129, 398], [41, 242], [282, 524], [267, 503], [95, 369]], 'tour_length': 442.64230763211816, 'objective': 442.64230763211816}","[0, 3, 6, 7, 10, 9, 2, 4, 5, 8, 1, 0]",442.64230763211816,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 35, 'y': 0, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 31, 'y': 8, 'tw_start': 257, 'tw_end': 542}, {'id': 'C', 'x': 100, 'y': 11, 'tw_start': 284, 'tw_end': 499}, {'id': 'D', 'x': 9, 'y': 21, 'tw_start': 12, 'tw_end': 231}, {'id': 'E', 'x': 49, 'y': 21, 'tw_start': 230, 'tw_end': 429}, {'id': 'F', 'x': 23, 'y': 23, 'tw_start': 192, 'tw_end': 444}, {'id': 'G', 'x': 12, 'y': 31, 'tw_start': 129, 'tw_end': 398}, {'id': 'H', 'x': 65, 'y': 38, 'tw_start': 41, 'tw_end': 242}, {'id': 'I', 'x': 0, 'y': 45, 'tw_start': 282, 'tw_end': 524}, {'id': 'J', 'x': 94, 'y': 99, 'tw_start': 267, 'tw_end': 503}, {'id': 'K', 'x': 66, 'y': 100, 'tw_start': 95, 'tw_end': 369}], 'depot': 'A', 'objective': 442.64230763211816}","['A', 'D', 'G', 'H', 'K', 'J', 'C', 'E', 'F', 'I', 'B', 'A']",36,markdown_table,names
TSPTW,TSPTW,"There’s a morning puzzle at the community shuttle: the van needs to head out from the depot, stop at each registered rider’s place exactly once during that rider’s pickup window (it can wait if it gets there too soon), and then return to base. The goal is straightforward in plain terms — keep the total driving distance down by summing all the segments of the route and picking the shortest possible loop that still meets everyone’s time window. No stop can be skipped or visited twice. Concrete details about riders, locations, and windows appear below.
Below are the 11 locations (including depot A) to visit in that loop.
| stop_id | x_coord | y_coord | pickup_window_start | pickup_window_end |
|---|---|---|---|---|
| A | 51 | 67 | 0 | 1067 |
| B | 45 | 77 | 310 | 571 |
| C | 56 | 71 | 105 | 356 |
| D | 27 | 15 | 140 | 342 |
| E | 19 | 88 | 355 | 563 |
| F | 80 | 33 | 368 | 605 |
| G | 58 | 0 | 71 | 318 |
| H | 100 | 17 | 338 | 603 |
| I | 56 | 100 | 312 | 570 |
| J | 23 | 21 | 268 | 544 |
| K | 0 | 37 | 96 | 338 |
The route must start and end at depot A, visiting each of the 11 locations exactly once within their windows.
Also, when you send the route back, just use this simple JSON layout so it's clear and easy to read:
{
""solution"": [depot_id, location_id, ..., depot_id]
}
""solution"" should be the ordered list of stops: start at the depot, visit each rider once in the order shown, and finish back at the depot. The names in the array above are placeholders to show the shape of the answer — this is just a sketch, not the actual route.
Please use the exact identifiers from the instance input — don’t rename or invent 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, 67], [45, 77], [56, 71], [27, 15], [19, 88], [80, 33], [58, 0], [100, 17], [56, 100], [23, 21], [0, 37]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [310, 571], [105, 356], [140, 342], [355, 563], [368, 605], [71, 318], [338, 603], [312, 570], [268, 544], [96, 338]], 'tour_length': 362.4655326481173, 'objective': 362.4655326481173}","[0, 2, 10, 9, 3, 6, 7, 5, 8, 4, 1, 0]",362.4655326481173,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 'A', 'x': 51, 'y': 67, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 45, 'y': 77, 'tw_start': 310, 'tw_end': 571}, {'id': 'C', 'x': 56, 'y': 71, 'tw_start': 105, 'tw_end': 356}, {'id': 'D', 'x': 27, 'y': 15, 'tw_start': 140, 'tw_end': 342}, {'id': 'E', 'x': 19, 'y': 88, 'tw_start': 355, 'tw_end': 563}, {'id': 'F', 'x': 80, 'y': 33, 'tw_start': 368, 'tw_end': 605}, {'id': 'G', 'x': 58, 'y': 0, 'tw_start': 71, 'tw_end': 318}, {'id': 'H', 'x': 100, 'y': 17, 'tw_start': 338, 'tw_end': 603}, {'id': 'I', 'x': 56, 'y': 100, 'tw_start': 312, 'tw_end': 570}, {'id': 'J', 'x': 23, 'y': 21, 'tw_start': 268, 'tw_end': 544}, {'id': 'K', 'x': 0, 'y': 37, 'tw_start': 96, 'tw_end': 338}], 'depot': 'A', 'objective': 362.4655326481173}","['A', 'C', 'K', 'J', 'D', 'G', 'H', 'F', 'I', 'E', 'B', 'A']",37,markdown_table,names
TSPTW,TSPTW,"There’s a repair crew that needs a daily run: one technician leaves the shop, visits each customer one time during their appointment window (they can hang out if they get there early), and then returns to the shop. The goal is to choose the sequence of stops so the total miles driven — the sum of distances from the shop through every house and back — is as small as possible. It’s important that every household gets exactly one visit and nobody is visited twice or left out. The concrete details follow below.
# total_locations_count=11
# shop_node=1
# time windows are listed per node in the table
location_id,coord_x,coord_y,appointment_window_start,appointment_window_end
1,70,68,0,1067
2,61,21,85,375
3,23,0,366,564
4,35,80,273,557
5,100,43,70,319
6,83,49,355,552
7,67,90,270,493
8,0,36,358,646
9,41,100,366,606
10,55,98,334,610
11,22,82,123,398
Also, when you send back the route, please put it in a little JSON sketch so it's easy to read and check. Something like this:
{
""solution"": [shop_id, customer_id, ..., shop_id]
}
Here ""solution"" is just the ordered list of stops for the day: start at the shop, go to each customer once, and come back to the shop. The placeholders shop_id and customer_id are just examples showing the kind of labels that go in the list — think of them like blanks you fill in with the actual IDs from the instance. This JSON is just the shape I want you to follow, not the real answer itself.
Please make sure you 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': [[70, 68], [61, 21], [23, 0], [35, 80], [100, 43], [83, 49], [67, 90], [0, 36], [41, 100], [55, 98], [22, 82]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [85, 375], [366, 564], [273, 557], [70, 319], [355, 552], [270, 493], [358, 646], [366, 606], [334, 610], [123, 398]], 'tour_length': 457.35809597637774, 'objective': 457.35809597637774}","[0, 4, 1, 3, 10, 8, 9, 6, 5, 2, 7, 0]",457.35809597637774,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 1, 'x': 70, 'y': 68, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 61, 'y': 21, 'tw_start': 85, 'tw_end': 375}, {'id': 3, 'x': 23, 'y': 0, 'tw_start': 366, 'tw_end': 564}, {'id': 4, 'x': 35, 'y': 80, 'tw_start': 273, 'tw_end': 557}, {'id': 5, 'x': 100, 'y': 43, 'tw_start': 70, 'tw_end': 319}, {'id': 6, 'x': 83, 'y': 49, 'tw_start': 355, 'tw_end': 552}, {'id': 7, 'x': 67, 'y': 90, 'tw_start': 270, 'tw_end': 493}, {'id': 8, 'x': 0, 'y': 36, 'tw_start': 358, 'tw_end': 646}, {'id': 9, 'x': 41, 'y': 100, 'tw_start': 366, 'tw_end': 606}, {'id': 10, 'x': 55, 'y': 98, 'tw_start': 334, 'tw_end': 610}, {'id': 11, 'x': 22, 'y': 82, 'tw_start': 123, 'tw_end': 398}], 'depot': 1, 'objective': 457.35809597637774}","[1, 5, 2, 4, 11, 9, 10, 7, 6, 3, 8, 1]",38,csv,1
TSPTW,TSPTW,"Someone has to map out the phlebotomist’s day so they can start at the lab, hit each appointment once within its window (it’s fine to wait if an appointment’s not open yet), and finish back at the lab. The clear goal is to pick the order of visits that yields the least total travel distance — simply add up the distances between stops and back to the lab to get that number. The full list of locations and their time slots appears below.
There are 13 locations including the lab 1 that must be visited in the route.
| stop_id | coord_x | coord_y | earliest_arrival_time | latest_arrival_time |
|---|---|---|---|---|
| 1 | 30 | 14 | 0 | 1067 |
| 2 | 38 | 88 | 14 | 266 |
| 3 | 50 | 30 | 89 | 294 |
| 4 | 4 | 82 | 29 | 291 |
| 5 | 21 | 45 | 131 | 396 |
| 6 | 100 | 21 | 25 | 249 |
| 7 | 75 | 76 | 209 | 480 |
| 8 | 81 | 100 | 123 | 378 |
| 9 | 48 | 88 | 343 | 597 |
| 10 | 0 | 50 | 90 | 286 |
| 11 | 0 | 26 | 337 | 533 |
| 12 | 39 | 60 | 339 | 584 |
| 13 | 1 | 0 | 364 | 635 |
Someone should choose the visit order that starts and ends at 1 and visits every appointment once, minimizing total travel distance.
You can just send back the visit order in a little JSON snippet like this so it's easy to read and use.
{
""solution"": [lab_id, appointment_id, ..., lab_id]
}
Think of that array as the day’s itinerary: start at the lab (the first lab_id), list each appointment once in the order you plan to visit them, and finish back at the lab (the final lab_id). It’s just a simple checklist-style list, nothing fancy.
Please use the exact identifiers that appear in 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': [[30, 14], [38, 88], [50, 30], [4, 82], [21, 45], [100, 21], [75, 76], [81, 100], [48, 88], [0, 50], [0, 26], [39, 60], [1, 0]], 'depot': 0, 'num_nodes': 13, 'time_windows': [[0, 1067], [14, 266], [89, 294], [29, 291], [131, 396], [25, 249], [209, 480], [123, 378], [343, 597], [90, 286], [337, 533], [339, 584], [364, 635]], 'tour_length': 479.91168268575274, 'objective': 479.91168268575274}","[0, 5, 2, 9, 3, 1, 6, 7, 8, 11, 4, 10, 12, 0]",479.91168268575274,"{'problem_type': 'TSPTW', 'num_nodes': 13, 'nodes': [{'id': 1, 'x': 30, 'y': 14, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 38, 'y': 88, 'tw_start': 14, 'tw_end': 266}, {'id': 3, 'x': 50, 'y': 30, 'tw_start': 89, 'tw_end': 294}, {'id': 4, 'x': 4, 'y': 82, 'tw_start': 29, 'tw_end': 291}, {'id': 5, 'x': 21, 'y': 45, 'tw_start': 131, 'tw_end': 396}, {'id': 6, 'x': 100, 'y': 21, 'tw_start': 25, 'tw_end': 249}, {'id': 7, 'x': 75, 'y': 76, 'tw_start': 209, 'tw_end': 480}, {'id': 8, 'x': 81, 'y': 100, 'tw_start': 123, 'tw_end': 378}, {'id': 9, 'x': 48, 'y': 88, 'tw_start': 343, 'tw_end': 597}, {'id': 10, 'x': 0, 'y': 50, 'tw_start': 90, 'tw_end': 286}, {'id': 11, 'x': 0, 'y': 26, 'tw_start': 337, 'tw_end': 533}, {'id': 12, 'x': 39, 'y': 60, 'tw_start': 339, 'tw_end': 584}, {'id': 13, 'x': 1, 'y': 0, 'tw_start': 364, 'tw_end': 635}], 'depot': 1, 'objective': 479.91168268575274}","[1, 6, 3, 10, 4, 2, 7, 8, 9, 12, 5, 11, 13, 1]",39,markdown_table,1
TSPTW,TSPTW,"Back at the warehouse the team is figuring out today’s loop: leave the yard, top up each stand one time only during that stand’s allowed restocking window (pauses are fine if the crew is early), and come home when done. The winning route is simply the one that minimizes total driving distance — add the distance from warehouse to the first stand, each stretch between successive stands, and the leg back to the warehouse to get the total. No stand can be skipped or repeated, and the concrete instance details follow below.
# total_locations_including_warehouse=14
# warehouse_id=1
# time windows are listed per node in the table
location_id,map_x_coordinate,map_y_coordinate,restock_window_start,restock_window_end
1,13,100,0,1067
2,6,91,387,615
3,26,28,297,530
4,0,7,186,441
5,96,93,338,628
6,55,98,298,532
7,48,100,163,429
8,46,31,92,297
9,48,7,137,359
10,50,4,114,331
11,53,1,16,212
12,99,0,383,618
13,100,20,149,409
14,96,27,84,370
Also, when you send the route back, just use this little JSON shape so it's easy to parse:
{
""solution"": [warehouse_id, stand_id, ..., warehouse_id]
}
Think of that as a simple form: ""solution"" holds the ordered list of stops — start at the warehouse, visit each stand exactly once (waiting is fine if you arrive early), and finish back at the warehouse. The names in the array are just placeholders showing the expected layout, not the real IDs.
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': [[13, 100], [6, 91], [26, 28], [0, 7], [96, 93], [55, 98], [48, 100], [46, 31], [48, 7], [50, 4], [53, 1], [99, 0], [100, 20], [96, 27]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [387, 615], [297, 530], [186, 441], [338, 628], [298, 532], [163, 429], [92, 297], [137, 359], [114, 331], [16, 212], [383, 618], [149, 409], [84, 370]], 'tour_length': 704.7391044144571, 'objective': 704.7391044144571}","[0, 7, 9, 10, 3, 8, 12, 13, 4, 5, 6, 1, 2, 11, 0]",704.7391044144571,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 1, 'x': 13, 'y': 100, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 6, 'y': 91, 'tw_start': 387, 'tw_end': 615}, {'id': 3, 'x': 26, 'y': 28, 'tw_start': 297, 'tw_end': 530}, {'id': 4, 'x': 0, 'y': 7, 'tw_start': 186, 'tw_end': 441}, {'id': 5, 'x': 96, 'y': 93, 'tw_start': 338, 'tw_end': 628}, {'id': 6, 'x': 55, 'y': 98, 'tw_start': 298, 'tw_end': 532}, {'id': 7, 'x': 48, 'y': 100, 'tw_start': 163, 'tw_end': 429}, {'id': 8, 'x': 46, 'y': 31, 'tw_start': 92, 'tw_end': 297}, {'id': 9, 'x': 48, 'y': 7, 'tw_start': 137, 'tw_end': 359}, {'id': 10, 'x': 50, 'y': 4, 'tw_start': 114, 'tw_end': 331}, {'id': 11, 'x': 53, 'y': 1, 'tw_start': 16, 'tw_end': 212}, {'id': 12, 'x': 99, 'y': 0, 'tw_start': 383, 'tw_end': 618}, {'id': 13, 'x': 100, 'y': 20, 'tw_start': 149, 'tw_end': 409}, {'id': 14, 'x': 96, 'y': 27, 'tw_start': 84, 'tw_end': 370}], 'depot': 1, 'objective': 704.7391044144571}","[1, 8, 10, 11, 4, 9, 13, 14, 5, 6, 7, 2, 3, 12, 1]",40,csv,1
TSPTW,TSPTW,"Someone who runs the medical-waste rounds needs a route that departs the facility, hits every clinic one time during its designated pickup period (waiting allowed if arriving early), and returns to the facility afterward. The key decision is the order of visits: different orders change the total driving needed, and the aim is to pick the order that leads to the least total driving distance — computed by summing each leg from the depot to the first stop, from each stop to the next, and finally back to the depot. Nothing can be skipped or doubled up, and each clinic’s pickup window must be obeyed. The detailed list of clinics, time windows, and distances is shown below.
There are 11 locations including the facility, and the facility node id is 0.
Location 0 is at (0, 17) and must be visited between 0 and 1067.
Location 1 is at (18, 30) and must be visited between 305 and 507.
Location 2 is at (25, 13) and must be visited between 162 and 441.
Location 3 is at (67, 54) and must be visited between 366 and 605.
Location 4 is at (70, 100) and must be visited between 238 and 448.
Location 5 is at (72, 0) and must be visited between 384 and 601.
Location 6 is at (81, 47) and must be visited between 365 and 622.
Location 7 is at (83, 69) and must be visited between 235 and 479.
Location 8 is at (84, 15) and must be visited between 89 and 300.
Location 9 is at (96, 23) and must be visited between 85 and 297.
Location 10 is at (100, 12) and must be visited between 302 and 530.
These entries should be used to select the visit order that minimizes total driving distance while obeying every pickup window and returning to the facility.
When you send the final route back, just drop it in this simple JSON shape so it's easy to pick up:
{
""solution"": [""depot_id"", ""location_id"", ""..."", ""depot_id""]
}
Pretty straightforward — ""solution"" is the ordered list of stops (start at the depot, visit each clinic once, and end at the depot). Think of the items in the array as the exact IDs you see in the instance (this JSON is only a sketch of the shape I expect, not the actual route).
Please use the identifiers exactly as they appear in the problem 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, 17], [18, 30], [25, 13], [67, 54], [70, 100], [72, 0], [81, 47], [83, 69], [84, 15], [96, 23], [100, 12]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [305, 507], [162, 441], [366, 605], [238, 448], [384, 601], [365, 622], [235, 479], [89, 300], [85, 297], [302, 530]], 'tour_length': 477.72078742760357, 'objective': 477.72078742760357}","[0, 2, 8, 9, 1, 3, 4, 7, 6, 10, 5, 0]",477.72078742760357,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 0, 'x': 0, 'y': 17, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 18, 'y': 30, 'tw_start': 305, 'tw_end': 507}, {'id': 2, 'x': 25, 'y': 13, 'tw_start': 162, 'tw_end': 441}, {'id': 3, 'x': 67, 'y': 54, 'tw_start': 366, 'tw_end': 605}, {'id': 4, 'x': 70, 'y': 100, 'tw_start': 238, 'tw_end': 448}, {'id': 5, 'x': 72, 'y': 0, 'tw_start': 384, 'tw_end': 601}, {'id': 6, 'x': 81, 'y': 47, 'tw_start': 365, 'tw_end': 622}, {'id': 7, 'x': 83, 'y': 69, 'tw_start': 235, 'tw_end': 479}, {'id': 8, 'x': 84, 'y': 15, 'tw_start': 89, 'tw_end': 300}, {'id': 9, 'x': 96, 'y': 23, 'tw_start': 85, 'tw_end': 297}, {'id': 10, 'x': 100, 'y': 12, 'tw_start': 302, 'tw_end': 530}], 'depot': 0, 'objective': 477.72078742760357}","[0, 2, 8, 9, 1, 3, 4, 7, 6, 10, 5, 0]",41,nl,0
TSPTW,TSPTW,"Recently a detailer had to plan a day of driveway cleanings: start at the garage, hit every driveway one time during the customer’s requested window (it’s okay to wait if the window isn’t open yet), and then come back to base. The only thing that separates a decent day from a great one is how little driving is done overall — just add up the distances of each leg (garage to first stop, between stops, and back) and choose the route with the smallest sum. No driveways can be skipped or repeated, and every job must fall inside its time slot. The concrete route data is shown below.
# total_locations_including_garage=14
# garage_node_id=A
# time windows are listed per node in the table
location_id,x_coordinate,y_coordinate,earliest_service_time,latest_service_time
A,14,83,0,1067
B,43,79,22,310
C,100,46,342,626
D,100,79,386,596
E,100,96,153,421
F,5,25,270,478
G,0,50,316,532
H,24,0,86,332
I,29,25,230,480
J,24,75,35,314
K,57,50,103,309
L,62,100,344,631
M,81,25,334,607
N,81,50,254,501
Also, when you give the final route, please stick to this simple JSON shape so it's easy to parse:
{
""solution"": [garage_id, driveway_id, ..., garage_id]
}
Here ""solution"" is just the ordered list of stops: start at the garage, list each driveway once in the order they’re visited (you can wait if a time slot isn’t open yet), and end back at the garage. Think of the placeholders as the labels you’ll fill in from the instance — just a form to show the visited sequence. This JSON is only 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 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': [[14, 83], [43, 79], [100, 46], [100, 79], [100, 96], [5, 25], [0, 50], [24, 0], [29, 25], [24, 75], [57, 50], [62, 100], [81, 25], [81, 50]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [22, 310], [342, 626], [386, 596], [153, 421], [270, 478], [316, 532], [86, 332], [230, 480], [35, 314], [103, 309], [344, 631], [334, 607], [254, 501]], 'tour_length': 531.1244131088996, 'objective': 531.1244131088996}","[0, 9, 1, 4, 10, 8, 7, 5, 6, 12, 13, 2, 3, 11, 0]",531.1244131088996,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 14, 'y': 83, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 43, 'y': 79, 'tw_start': 22, 'tw_end': 310}, {'id': 'C', 'x': 100, 'y': 46, 'tw_start': 342, 'tw_end': 626}, {'id': 'D', 'x': 100, 'y': 79, 'tw_start': 386, 'tw_end': 596}, {'id': 'E', 'x': 100, 'y': 96, 'tw_start': 153, 'tw_end': 421}, {'id': 'F', 'x': 5, 'y': 25, 'tw_start': 270, 'tw_end': 478}, {'id': 'G', 'x': 0, 'y': 50, 'tw_start': 316, 'tw_end': 532}, {'id': 'H', 'x': 24, 'y': 0, 'tw_start': 86, 'tw_end': 332}, {'id': 'I', 'x': 29, 'y': 25, 'tw_start': 230, 'tw_end': 480}, {'id': 'J', 'x': 24, 'y': 75, 'tw_start': 35, 'tw_end': 314}, {'id': 'K', 'x': 57, 'y': 50, 'tw_start': 103, 'tw_end': 309}, {'id': 'L', 'x': 62, 'y': 100, 'tw_start': 344, 'tw_end': 631}, {'id': 'M', 'x': 81, 'y': 25, 'tw_start': 334, 'tw_end': 607}, {'id': 'N', 'x': 81, 'y': 50, 'tw_start': 254, 'tw_end': 501}], 'depot': 'A', 'objective': 531.1244131088996}","['A', 'J', 'B', 'E', 'K', 'I', 'H', 'F', 'G', 'M', 'N', 'C', 'D', 'L', 'A']",42,csv,names
TSPTW,TSPTW,"Back at the store the dispatcher sketches a run: the truck must leave the store, visit every customer exactly once to deliver during the customer’s specified time window (waiting is allowed), and return to the starting point. The planner’s job is to pick the order of customers, since that order sets the total miles traveled. The “better” plan is simply the one that results in fewer total miles — figured by summing the distance between each consecutive stop plus the return leg. The concrete details are listed below.
# total_locations_including_store=13
# store_node_id=0
# time windows are listed per node in the table
location_id,x_coordinate,y_coordinate,earliest_delivery_time,latest_delivery_time
0,0,45,0,1067
1,4,36,33,267
2,22,100,144,363
3,30,64,280,522
4,41,9,31,246
5,44,76,265,466
6,59,45,330,572
7,67,0,186,437
8,89,42,319,547
9,93,27,263,511
10,100,33,103,382
11,20,68,309,567
12,83,12,330,608
Just so we're on the same page, send the route back in this simple JSON shape — an ordered list of stop IDs starting and ending at the store.
{
""solution"": [""store_id"", ""customer_id"", ""..."", ""store_id""]
}
Think of this like a little form: the array is the run in order, the first entry is where the truck leaves from, the last entry is where it comes back to, and everything in between is each customer visited exactly once. This JSON is just a sketch of the shape I expect, not the actual route.
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': [[0, 45], [4, 36], [22, 100], [30, 64], [41, 9], [44, 76], [59, 45], [67, 0], [89, 42], [93, 27], [100, 33], [20, 68], [83, 12]], 'depot': 0, 'num_nodes': 13, 'time_windows': [[0, 1067], [33, 267], [144, 363], [280, 522], [31, 246], [265, 466], [330, 572], [186, 437], [319, 547], [263, 511], [103, 382], [309, 567], [330, 608]], 'tour_length': 382.54479796819044, 'objective': 382.54479796819044}","[0, 1, 2, 4, 7, 12, 9, 10, 8, 6, 5, 3, 11, 0]",382.54479796819044,"{'problem_type': 'TSPTW', 'num_nodes': 13, 'nodes': [{'id': 0, 'x': 0, 'y': 45, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 4, 'y': 36, 'tw_start': 33, 'tw_end': 267}, {'id': 2, 'x': 22, 'y': 100, 'tw_start': 144, 'tw_end': 363}, {'id': 3, 'x': 30, 'y': 64, 'tw_start': 280, 'tw_end': 522}, {'id': 4, 'x': 41, 'y': 9, 'tw_start': 31, 'tw_end': 246}, {'id': 5, 'x': 44, 'y': 76, 'tw_start': 265, 'tw_end': 466}, {'id': 6, 'x': 59, 'y': 45, 'tw_start': 330, 'tw_end': 572}, {'id': 7, 'x': 67, 'y': 0, 'tw_start': 186, 'tw_end': 437}, {'id': 8, 'x': 89, 'y': 42, 'tw_start': 319, 'tw_end': 547}, {'id': 9, 'x': 93, 'y': 27, 'tw_start': 263, 'tw_end': 511}, {'id': 10, 'x': 100, 'y': 33, 'tw_start': 103, 'tw_end': 382}, {'id': 11, 'x': 20, 'y': 68, 'tw_start': 309, 'tw_end': 567}, {'id': 12, 'x': 83, 'y': 12, 'tw_start': 330, 'tw_end': 608}], 'depot': 0, 'objective': 382.54479796819044}","[0, 1, 2, 4, 7, 12, 9, 10, 8, 6, 5, 3, 11, 0]",43,csv,0
TSPTW,TSPTW,"Back at the office the scheduler lays out a run: start and end at the office, visit every meter site once and only once, and make sure each visit falls inside that site's permitted time slot (waiting ahead of the slot is allowed). The decision is how to arrange the stops so the whole loop uses the least driving — figured by adding up the distances between consecutive stops and the return trip. Every meter must be visited exactly one time, and the precise locations and their access windows are provided below.
{
""total_locations_including_office"": 14,
""nodes"": [
{
""site_id"": ""A"",
""x_coordinate"": 90,
""y_coordinate"": 91,
""access_window_start"": 0,
""access_window_end"": 1067
},
{
""site_id"": ""B"",
""x_coordinate"": 0,
""y_coordinate"": 40,
""access_window_start"": 274,
""access_window_end"": 550
},
{
""site_id"": ""C"",
""x_coordinate"": 23,
""y_coordinate"": 46,
""access_window_start"": 270,
""access_window_end"": 530
},
{
""site_id"": ""D"",
""x_coordinate"": 75,
""y_coordinate"": 88,
""access_window_start"": 240,
""access_window_end"": 507
},
{
""site_id"": ""E"",
""x_coordinate"": 58,
""y_coordinate"": 100,
""access_window_start"": 61,
""access_window_end"": 340
},
{
""site_id"": ""F"",
""x_coordinate"": 48,
""y_coordinate"": 29,
""access_window_start"": 338,
""access_window_end"": 535
},
{
""site_id"": ""G"",
""x_coordinate"": 100,
""y_coordinate"": 91,
""access_window_start"": 320,
""access_window_end"": 526
},
{
""site_id"": ""H"",
""x_coordinate"": 21,
""y_coordinate"": 84,
""access_window_start"": 130,
""access_window_end"": 396
},
{
""site_id"": ""I"",
""x_coordinate"": 3,
""y_coordinate"": 43,
""access_window_start"": 62,
""access_window_end"": 335
},
{
""site_id"": ""J"",
""x_coordinate"": 41,
""y_coordinate"": 90,
""access_window_start"": 322,
""access_window_end"": 566
},
{
""site_id"": ""K"",
""x_coordinate"": 45,
""y_coordinate"": 32,
""access_window_start"": 2,
""access_window_end"": 224
},
{
""site_id"": ""L"",
""x_coordinate"": 64,
""y_coordinate"": 60,
""access_window_start"": 239,
""access_window_end"": 528
},
{
""site_id"": ""M"",
""x_coordinate"": 41,
""y_coordinate"": 2,
""access_window_start"": 245,
""access_window_end"": 464
},
{
""site_id"": ""N"",
""x_coordinate"": 21,
""y_coordinate"": 0,
""access_window_start"": 245,
""access_window_end"": 492
}
],
""office_node_id"": ""A""
}
Also, when you send the route back, just use this simple JSON shape so I can read it easily:
{
""solution"": [office_id, site_id, ..., office_id]
}
Think of that as a little form: ""solution"" holds the stop-by-stop order of the loop (starting and ending at the office). office_id and site_id are just placeholders for the actual site identifiers in your instance, and the ... stands in for the other stops in between. This is just the shape I want — not the real answer filled in.
Please make sure you 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': [[90, 91], [0, 40], [23, 46], [75, 88], [58, 100], [48, 29], [100, 91], [21, 84], [3, 43], [41, 90], [45, 32], [64, 60], [41, 2], [21, 0]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [274, 550], [270, 530], [240, 507], [61, 340], [338, 535], [320, 526], [130, 396], [62, 335], [322, 566], [2, 224], [239, 528], [245, 464], [245, 492]], 'tour_length': 416.4629153761622, 'objective': 416.4629153761622}","[0, 4, 7, 10, 2, 8, 1, 13, 12, 5, 11, 9, 3, 6, 0]",416.4629153761622,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 90, 'y': 91, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 0, 'y': 40, 'tw_start': 274, 'tw_end': 550}, {'id': 'C', 'x': 23, 'y': 46, 'tw_start': 270, 'tw_end': 530}, {'id': 'D', 'x': 75, 'y': 88, 'tw_start': 240, 'tw_end': 507}, {'id': 'E', 'x': 58, 'y': 100, 'tw_start': 61, 'tw_end': 340}, {'id': 'F', 'x': 48, 'y': 29, 'tw_start': 338, 'tw_end': 535}, {'id': 'G', 'x': 100, 'y': 91, 'tw_start': 320, 'tw_end': 526}, {'id': 'H', 'x': 21, 'y': 84, 'tw_start': 130, 'tw_end': 396}, {'id': 'I', 'x': 3, 'y': 43, 'tw_start': 62, 'tw_end': 335}, {'id': 'J', 'x': 41, 'y': 90, 'tw_start': 322, 'tw_end': 566}, {'id': 'K', 'x': 45, 'y': 32, 'tw_start': 2, 'tw_end': 224}, {'id': 'L', 'x': 64, 'y': 60, 'tw_start': 239, 'tw_end': 528}, {'id': 'M', 'x': 41, 'y': 2, 'tw_start': 245, 'tw_end': 464}, {'id': 'N', 'x': 21, 'y': 0, 'tw_start': 245, 'tw_end': 492}], 'depot': 'A', 'objective': 416.4629153761622}","['A', 'E', 'H', 'K', 'C', 'I', 'B', 'N', 'M', 'F', 'L', 'J', 'D', 'G', 'A']",44,json,names
TSPTW,TSPTW,"Many households booked cleanings for the same day, and the team must be routed from the office through every address one time and back to the office, all while respecting each household’s allowed arrival period (a bit of waiting is fine). The question is which order to visit the homes so the crew can hit all the time slots without going back over the same address. A better schedule is simply the one that results in fewer kilometers driven overall — compute that by adding the distances for every consecutive hop in the route, including leaving and returning to the office. The detailed bookings and windows are listed below.
There are 14 locations including the office; the office is node A.
| location_id | location_x_coordinate | location_y_coordinate | earliest_allowed_arrival | latest_allowed_arrival |
|---|---|---|---|---|
| A | 3 | 49 | 0 | 1067 |
| B | 41 | 1 | 302 | 506 |
| C | 89 | 39 | 295 | 541 |
| D | 69 | 66 | 373 | 600 |
| E | 86 | 17 | 245 | 529 |
| F | 92 | 0 | 39 | 324 |
| G | 100 | 16 | 266 | 467 |
| H | 100 | 32 | 116 | 379 |
| I | 82 | 96 | 26 | 276 |
| J | 35 | 76 | 134 | 388 |
| K | 25 | 21 | 17 | 296 |
| L | 30 | 43 | 377 | 665 |
| M | 16 | 99 | 290 | 497 |
| N | 0 | 100 | 294 | 490 |
Plan a tour that visits each location once and returns to the office at node A while respecting all arrival windows and minimizing kilometers driven.
Also, when you give the final route, please use a tiny JSON layout like this so it's easy to parse:
{
""solution"": [office_id, address_id, ..., office_id]
}
This just shows the shape I want — ""solution"" is the ordered list of stops, starting at the office, visiting every home once, and coming back to the office. Think of it like filling in the visit order on a simple form; replace each placeholder with the matching identifier from the instance. The JSON above is only a sketch of the expected shape, not the actual answer.
All identifiers must be used exactly as they appear 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': [[3, 49], [41, 1], [89, 39], [69, 66], [86, 17], [92, 0], [100, 16], [100, 32], [82, 96], [35, 76], [25, 21], [30, 43], [16, 99], [0, 100]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [302, 506], [295, 541], [373, 600], [245, 529], [39, 324], [266, 467], [116, 379], [26, 276], [134, 388], [17, 296], [377, 665], [290, 497], [294, 490]], 'tour_length': 557.2349161922258, 'objective': 557.2349161922258}","[0, 10, 5, 7, 8, 12, 13, 9, 3, 2, 6, 4, 1, 11, 0]",557.2349161922258,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 'A', 'x': 3, 'y': 49, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 41, 'y': 1, 'tw_start': 302, 'tw_end': 506}, {'id': 'C', 'x': 89, 'y': 39, 'tw_start': 295, 'tw_end': 541}, {'id': 'D', 'x': 69, 'y': 66, 'tw_start': 373, 'tw_end': 600}, {'id': 'E', 'x': 86, 'y': 17, 'tw_start': 245, 'tw_end': 529}, {'id': 'F', 'x': 92, 'y': 0, 'tw_start': 39, 'tw_end': 324}, {'id': 'G', 'x': 100, 'y': 16, 'tw_start': 266, 'tw_end': 467}, {'id': 'H', 'x': 100, 'y': 32, 'tw_start': 116, 'tw_end': 379}, {'id': 'I', 'x': 82, 'y': 96, 'tw_start': 26, 'tw_end': 276}, {'id': 'J', 'x': 35, 'y': 76, 'tw_start': 134, 'tw_end': 388}, {'id': 'K', 'x': 25, 'y': 21, 'tw_start': 17, 'tw_end': 296}, {'id': 'L', 'x': 30, 'y': 43, 'tw_start': 377, 'tw_end': 665}, {'id': 'M', 'x': 16, 'y': 99, 'tw_start': 290, 'tw_end': 497}, {'id': 'N', 'x': 0, 'y': 100, 'tw_start': 294, 'tw_end': 490}], 'depot': 'A', 'objective': 557.2349161922258}","['A', 'K', 'F', 'H', 'I', 'M', 'N', 'J', 'D', 'C', 'G', 'E', 'B', 'L', 'A']",45,markdown_table,names
TSPTW,TSPTW,"I pictured a sales rep leaving the branch in the morning, swinging by a handful of prospects, and then heading back to the office at the end of the day. The trick is picking the order to visit so every prospective client is seen exactly once, each meeting happens inside the slot they gave, and the rep doesn’t rack up more driving than necessary — total distance is just the sum of the miles between stops (including the trip home), so the plan with the smallest sum is the nicer one. If the rep gets to a place early, waiting until the meeting window opens is fine, but nobody can be skipped or visited twice. The exact locations, times, and distances are listed below.
There are 13 locations including the branch office (depot node 0).
| location_id | location_x | location_y | earliest_meeting_time | latest_meeting_time |
|---|---|---|---|---|
| 0 | 0 | 23 | 0 | 1067 |
| 1 | 5 | 41 | 8 | 233 |
| 2 | 2 | 55 | 189 | 458 |
| 3 | 0 | 59 | 265 | 502 |
| 4 | 5 | 59 | 106 | 396 |
| 5 | 2 | 80 | 165 | 403 |
| 6 | 0 | 100 | 63 | 334 |
| 7 | 7 | 100 | 269 | 484 |
| 8 | 100 | 0 | 31 | 291 |
| 9 | 95 | 75 | 253 | 474 |
| 10 | 100 | 80 | 368 | 577 |
| 11 | 95 | 100 | 167 | 453 |
| 12 | 100 | 100 | 162 | 418 |
I'll pick the shortest valid tour among the 13 locations that starts and ends at depot 0.
If you want the route in a neat, machine-friendly form, just drop it into a tiny JSON object like this:
{
""solution"": [branch_id, location_id, ..., branch_id]
}
Think of that as: ""solution"" is the list that gives the visit order — start at the branch (first placeholder), go visit each prospect once (the middle placeholders), and come back to the branch (last placeholder). This is just a sketch of the shape I expect, not the actual route.
Please use the exact identifiers from the instance input — no renaming and no invented 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, 23], [5, 41], [2, 55], [0, 59], [5, 59], [2, 80], [0, 100], [7, 100], [100, 0], [95, 75], [100, 80], [95, 100], [100, 100]], 'depot': 0, 'num_nodes': 13, 'time_windows': [[0, 1067], [8, 233], [189, 458], [265, 502], [106, 396], [165, 403], [63, 334], [269, 484], [31, 291], [253, 474], [368, 577], [167, 453], [162, 418]], 'tour_length': 506.55520531202313, 'objective': 506.55520531202313}","[0, 8, 1, 2, 3, 4, 5, 6, 7, 11, 12, 10, 9, 0]",506.55520531202313,"{'problem_type': 'TSPTW', 'num_nodes': 13, 'nodes': [{'id': 0, 'x': 0, 'y': 23, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 5, 'y': 41, 'tw_start': 8, 'tw_end': 233}, {'id': 2, 'x': 2, 'y': 55, 'tw_start': 189, 'tw_end': 458}, {'id': 3, 'x': 0, 'y': 59, 'tw_start': 265, 'tw_end': 502}, {'id': 4, 'x': 5, 'y': 59, 'tw_start': 106, 'tw_end': 396}, {'id': 5, 'x': 2, 'y': 80, 'tw_start': 165, 'tw_end': 403}, {'id': 6, 'x': 0, 'y': 100, 'tw_start': 63, 'tw_end': 334}, {'id': 7, 'x': 7, 'y': 100, 'tw_start': 269, 'tw_end': 484}, {'id': 8, 'x': 100, 'y': 0, 'tw_start': 31, 'tw_end': 291}, {'id': 9, 'x': 95, 'y': 75, 'tw_start': 253, 'tw_end': 474}, {'id': 10, 'x': 100, 'y': 80, 'tw_start': 368, 'tw_end': 577}, {'id': 11, 'x': 95, 'y': 100, 'tw_start': 167, 'tw_end': 453}, {'id': 12, 'x': 100, 'y': 100, 'tw_start': 162, 'tw_end': 418}], 'depot': 0, 'objective': 506.55520531202313}","[0, 8, 1, 2, 3, 4, 5, 6, 7, 11, 12, 10, 9, 0]",46,markdown_table,0
TSPTW,TSPTW,"Recently the logistics team had to map out a route where a researcher leaves the basecamp, stops at every survey point exactly once to collect data, and ends the day back at basecamp. Each stop has its own allowed sampling hours, so arrivals must be within those windows (it’s acceptable to hang around a bit if the window hasn’t started), and no detours that repeat sites or skip them are permitted. The goal is to minimize how much they have to drive — check that by totaling the distances of all legs of the trip — and the concrete site/timing info appears below.
# total_sites_including_basecamp=14
# basecamp_node_id=0
# time windows are listed per node in the table
site_id,coord_x,coord_y,earliest_sampling_time,latest_sampling_time
0,50,33,0,1067
1,93,70,154,374
2,61,67,381,615
3,54,57,346,563
4,86,56,82,279
5,0,53,252,482
6,52,31,335,575
7,52,21,375,587
8,85,23,337,606
9,19,72,299,575
10,73,52,295,550
11,86,23,50,248
12,18,100,357,611
13,100,0,309,549
Oh, and when you send the final route back, please use a tiny JSON snippet like this so it's easy to parse:
{
""solution"": [basecamp_id, survey_point_id, ..., basecamp_id]
}
This just means: ""solution"" is the ordered list of stops for the day, starting and ending at the basecamp, with every survey point shown in the order they'll be visited. The tokens in the list (like basecamp_id and survey_point_id) are placeholders for the actual site identifiers from the instance — this block is just a sketch of the shape I expect, not the real answer.
Please use the exact identifiers from the instance input with no renaming and don’t introduce 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': [[50, 33], [93, 70], [61, 67], [54, 57], [86, 56], [0, 53], [52, 31], [52, 21], [85, 23], [19, 72], [73, 52], [86, 23], [18, 100], [100, 0]], 'depot': 0, 'num_nodes': 14, 'time_windows': [[0, 1067], [154, 374], [381, 615], [346, 563], [82, 279], [252, 482], [335, 575], [375, 587], [337, 606], [299, 575], [295, 550], [50, 248], [357, 611], [309, 549]], 'tour_length': 445.56616881725824, 'objective': 445.56616881725824}","[0, 11, 4, 1, 5, 9, 12, 2, 3, 10, 8, 13, 7, 6, 0]",445.56616881725824,"{'problem_type': 'TSPTW', 'num_nodes': 14, 'nodes': [{'id': 0, 'x': 50, 'y': 33, 'tw_start': 0, 'tw_end': 1067}, {'id': 1, 'x': 93, 'y': 70, 'tw_start': 154, 'tw_end': 374}, {'id': 2, 'x': 61, 'y': 67, 'tw_start': 381, 'tw_end': 615}, {'id': 3, 'x': 54, 'y': 57, 'tw_start': 346, 'tw_end': 563}, {'id': 4, 'x': 86, 'y': 56, 'tw_start': 82, 'tw_end': 279}, {'id': 5, 'x': 0, 'y': 53, 'tw_start': 252, 'tw_end': 482}, {'id': 6, 'x': 52, 'y': 31, 'tw_start': 335, 'tw_end': 575}, {'id': 7, 'x': 52, 'y': 21, 'tw_start': 375, 'tw_end': 587}, {'id': 8, 'x': 85, 'y': 23, 'tw_start': 337, 'tw_end': 606}, {'id': 9, 'x': 19, 'y': 72, 'tw_start': 299, 'tw_end': 575}, {'id': 10, 'x': 73, 'y': 52, 'tw_start': 295, 'tw_end': 550}, {'id': 11, 'x': 86, 'y': 23, 'tw_start': 50, 'tw_end': 248}, {'id': 12, 'x': 18, 'y': 100, 'tw_start': 357, 'tw_end': 611}, {'id': 13, 'x': 100, 'y': 0, 'tw_start': 309, 'tw_end': 549}], 'depot': 0, 'objective': 445.56616881725824}","[0, 11, 4, 1, 5, 9, 12, 2, 3, 10, 8, 13, 7, 6, 0]",47,csv,0
TSPTW,TSPTW,"Someone at the shop is mapping out the day’s bouquet drops: the route must start and finish at the store, visit every delivery address exactly once, and hit each recipient within their promised delivery window. Hanging around until a window opens is allowed, but any route that racks up more driving distance is worse — total distance is just the sum of the driving between each pair of stops, including coming back to the shop. The specific locations and their time slots are shown below.
There are 13 locations in total and the shop is node 1.
| stop_id | location_x | location_y | earliest_delivery_time | latest_delivery_time |
|---|---|---|---|---|
| 1 | 0 | 84 | 0 | 1067 |
| 2 | 27 | 100 | 45 | 251 |
| 3 | 40 | 98 | 265 | 501 |
| 4 | 70 | 94 | 77 | 319 |
| 5 | 89 | 42 | 24 | 275 |
| 6 | 86 | 34 | 104 | 375 |
| 7 | 85 | 32 | 120 | 358 |
| 8 | 80 | 26 | 4 | 205 |
| 9 | 74 | 20 | 152 | 392 |
| 10 | 81 | 15 | 232 | 455 |
| 11 | 79 | 3 | 269 | 547 |
| 12 | 81 | 3 | 302 | 500 |
| 13 | 100 | 0 | 186 | 390 |
Plan a route that visits all 13 locations and returns to 1, meeting each delivery window while keeping total driving distance as low as possible.
Also, when you send the route back, just stick to a tiny JSON shape like this — nothing fancy:
{
""solution"": [""shop_id"", ""address_id"", ""..."", ""shop_id""]
}
This just means: ""solution"" holds the tour as an ordered list of stops — start at the shop, list each delivery address once in the order you'll visit them, and finish back at the shop. Think of the placeholders ( shop_id, address_id ) as blanks you'll fill with the actual IDs from the instance.
This JSON is only a sketch of the expected shape, not the real answer.
Please 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': [[0, 84], [27, 100], [40, 98], [70, 94], [89, 42], [86, 34], [85, 32], [80, 26], [74, 20], [81, 15], [79, 3], [81, 3], [100, 0]], 'depot': 0, 'num_nodes': 13, 'time_windows': [[0, 1067], [45, 251], [265, 501], [77, 319], [24, 275], [104, 375], [120, 358], [4, 205], [152, 392], [232, 455], [269, 547], [302, 500], [186, 390]], 'tour_length': 350.429716731438, 'objective': 350.429716731438}","[0, 1, 3, 4, 5, 6, 7, 9, 12, 11, 10, 8, 2, 0]",350.429716731438,"{'problem_type': 'TSPTW', 'num_nodes': 13, 'nodes': [{'id': 1, 'x': 0, 'y': 84, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 27, 'y': 100, 'tw_start': 45, 'tw_end': 251}, {'id': 3, 'x': 40, 'y': 98, 'tw_start': 265, 'tw_end': 501}, {'id': 4, 'x': 70, 'y': 94, 'tw_start': 77, 'tw_end': 319}, {'id': 5, 'x': 89, 'y': 42, 'tw_start': 24, 'tw_end': 275}, {'id': 6, 'x': 86, 'y': 34, 'tw_start': 104, 'tw_end': 375}, {'id': 7, 'x': 85, 'y': 32, 'tw_start': 120, 'tw_end': 358}, {'id': 8, 'x': 80, 'y': 26, 'tw_start': 4, 'tw_end': 205}, {'id': 9, 'x': 74, 'y': 20, 'tw_start': 152, 'tw_end': 392}, {'id': 10, 'x': 81, 'y': 15, 'tw_start': 232, 'tw_end': 455}, {'id': 11, 'x': 79, 'y': 3, 'tw_start': 269, 'tw_end': 547}, {'id': 12, 'x': 81, 'y': 3, 'tw_start': 302, 'tw_end': 500}, {'id': 13, 'x': 100, 'y': 0, 'tw_start': 186, 'tw_end': 390}], 'depot': 1, 'objective': 350.429716731438}","[1, 2, 4, 5, 6, 7, 8, 10, 13, 12, 11, 9, 3, 1]",48,markdown_table,1
TSPTW,TSPTW,"We have an outreach plan to make: a counselor leaves the service center, drops by every household on a roster exactly once, and comes back to base. The aim is to arrange the order of visits so every household is met within its available meeting window and the total distance driven is as small as possible — tally the distance between each consecutive stop and the final leg home, and that total should be minimized. Waiting at a house if the counselor gets there before the window starts is allowed, but no household can be skipped or visited twice. The concrete list of homes and their time windows is provided below.
# total_locations_including_service_center=11
# service_center_id=1
# time windows are listed per node in the table
location_id,x_coordinate,y_coordinate,earliest_meeting_time,latest_meeting_time
1,98,73,0,1067
2,10,31,12,297
3,81,100,20,266
4,97,0,275,553
5,41,23,277,548
6,55,17,131,404
7,100,44,31,311
8,14,15,212,485
9,0,26,175,431
10,68,11,204,469
11,77,85,31,231
Also, when you send the actual plan back, please use this simple JSON shape so it's easy to read and check:
{
""solution"": [center_id, house_id, ..., center_id]
}
This just means: ""solution"" is a list showing the visit order — start at the service center, list each household exactly once in the order they'll be visited, and finish back at the center. The names in the example above are just placeholders to show the shape, not the real labels you'll use.
Please make sure to use the exact identifiers from 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': [[98, 73], [10, 31], [81, 100], [97, 0], [41, 23], [55, 17], [100, 44], [14, 15], [0, 26], [68, 11], [77, 85]], 'depot': 0, 'num_nodes': 11, 'time_windows': [[0, 1067], [12, 297], [20, 266], [275, 553], [277, 548], [131, 404], [31, 311], [212, 485], [175, 431], [204, 469], [31, 231]], 'tour_length': 376.09239657823724, 'objective': 376.09239657823724}","[0, 2, 10, 6, 1, 8, 7, 4, 5, 9, 3, 0]",376.09239657823724,"{'problem_type': 'TSPTW', 'num_nodes': 11, 'nodes': [{'id': 1, 'x': 98, 'y': 73, 'tw_start': 0, 'tw_end': 1067}, {'id': 2, 'x': 10, 'y': 31, 'tw_start': 12, 'tw_end': 297}, {'id': 3, 'x': 81, 'y': 100, 'tw_start': 20, 'tw_end': 266}, {'id': 4, 'x': 97, 'y': 0, 'tw_start': 275, 'tw_end': 553}, {'id': 5, 'x': 41, 'y': 23, 'tw_start': 277, 'tw_end': 548}, {'id': 6, 'x': 55, 'y': 17, 'tw_start': 131, 'tw_end': 404}, {'id': 7, 'x': 100, 'y': 44, 'tw_start': 31, 'tw_end': 311}, {'id': 8, 'x': 14, 'y': 15, 'tw_start': 212, 'tw_end': 485}, {'id': 9, 'x': 0, 'y': 26, 'tw_start': 175, 'tw_end': 431}, {'id': 10, 'x': 68, 'y': 11, 'tw_start': 204, 'tw_end': 469}, {'id': 11, 'x': 77, 'y': 85, 'tw_start': 31, 'tw_end': 231}], 'depot': 1, 'objective': 376.09239657823724}","[1, 3, 11, 7, 2, 9, 8, 5, 6, 10, 4, 1]",49,csv,1
TSPTW,TSPTW,"Across town there’s a charity van that needs a single, tidy loop: start at the depot, visit each distribution site one time only, and come back to the depot, all while making sure each visit falls inside that site’s receiving hours (waiting is okay if the van shows up early). The deciding factor is total miles driven — add together the distances of each leg in the journey to get the total, and aim for the route with the smallest number. The concrete route data and time windows are shown below.
{
""total_locations_including_depot"": 12,
""nodes"": [
{
""location_id"": ""A"",
""x_coordinate"": 0,
""y_coordinate"": 62,
""earliest_receiving_time"": 0,
""latest_receiving_time"": 1067
},
{
""location_id"": ""B"",
""x_coordinate"": 0,
""y_coordinate"": 100,
""earliest_receiving_time"": 95,
""latest_receiving_time"": 305
},
{
""location_id"": ""C"",
""x_coordinate"": 87,
""y_coordinate"": 81,
""earliest_receiving_time"": 338,
""latest_receiving_time"": 553
},
{
""location_id"": ""D"",
""x_coordinate"": 77,
""y_coordinate"": 93,
""earliest_receiving_time"": 378,
""latest_receiving_time"": 605
},
{
""location_id"": ""E"",
""x_coordinate"": 92,
""y_coordinate"": 40,
""earliest_receiving_time"": 70,
""latest_receiving_time"": 341
},
{
""location_id"": ""F"",
""x_coordinate"": 100,
""y_coordinate"": 43,
""earliest_receiving_time"": 255,
""latest_receiving_time"": 497
},
{
""location_id"": ""G"",
""x_coordinate"": 62,
""y_coordinate"": 0,
""earliest_receiving_time"": 215,
""latest_receiving_time"": 479
},
{
""location_id"": ""H"",
""x_coordinate"": 50,
""y_coordinate"": 14,
""earliest_receiving_time"": 88,
""latest_receiving_time"": 379
},
{
""location_id"": ""I"",
""x_coordinate"": 8,
""y_coordinate"": 43,
""earliest_receiving_time"": 378,
""latest_receiving_time"": 635
},
{
""location_id"": ""J"",
""x_coordinate"": 8,
""y_coordinate"": 33,
""earliest_receiving_time"": 77,
""latest_receiving_time"": 337
},
{
""location_id"": ""K"",
""x_coordinate"": 10,
""y_coordinate"": 21,
""earliest_receiving_time"": 28,
""latest_receiving_time"": 224
},
{
""location_id"": ""L"",
""x_coordinate"": 4,
""y_coordinate"": 2,
""earliest_receiving_time"": 99,
""latest_receiving_time"": 338
}
],
""depot_node_id"": ""A""
}
If you'd like the answer in a tidy, machine-friendly form, just use this simple layout:
{
""solution"": [depot_id, location_id, ..., depot_id]
}
Here ""solution"" is an ordered list showing the van's loop — start at the depot, visit each site once (in the order shown), and come back to the depot. Think of it like filling in a short itinerary: each entry is the identifier for the spot visited, in travel order. This JSON is just a sketch of the shape I expect the real answer to take, not the actual route.
Please make sure to 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': [[0, 62], [0, 100], [87, 81], [77, 93], [92, 40], [100, 43], [62, 0], [50, 14], [8, 43], [8, 33], [10, 21], [4, 2]], 'depot': 0, 'num_nodes': 12, 'time_windows': [[0, 1067], [95, 305], [338, 553], [378, 605], [70, 341], [255, 497], [215, 479], [88, 379], [378, 635], [77, 337], [28, 224], [99, 338]], 'tour_length': 423.69855580007805, 'objective': 423.69855580007805}","[0, 1, 9, 10, 11, 7, 6, 4, 5, 2, 3, 8, 0]",423.69855580007805,"{'problem_type': 'TSPTW', 'num_nodes': 12, 'nodes': [{'id': 'A', 'x': 0, 'y': 62, 'tw_start': 0, 'tw_end': 1067}, {'id': 'B', 'x': 0, 'y': 100, 'tw_start': 95, 'tw_end': 305}, {'id': 'C', 'x': 87, 'y': 81, 'tw_start': 338, 'tw_end': 553}, {'id': 'D', 'x': 77, 'y': 93, 'tw_start': 378, 'tw_end': 605}, {'id': 'E', 'x': 92, 'y': 40, 'tw_start': 70, 'tw_end': 341}, {'id': 'F', 'x': 100, 'y': 43, 'tw_start': 255, 'tw_end': 497}, {'id': 'G', 'x': 62, 'y': 0, 'tw_start': 215, 'tw_end': 479}, {'id': 'H', 'x': 50, 'y': 14, 'tw_start': 88, 'tw_end': 379}, {'id': 'I', 'x': 8, 'y': 43, 'tw_start': 378, 'tw_end': 635}, {'id': 'J', 'x': 8, 'y': 33, 'tw_start': 77, 'tw_end': 337}, {'id': 'K', 'x': 10, 'y': 21, 'tw_start': 28, 'tw_end': 224}, {'id': 'L', 'x': 4, 'y': 2, 'tw_start': 99, 'tw_end': 338}], 'depot': 'A', 'objective': 423.69855580007805}","['A', 'B', 'J', 'K', 'L', 'H', 'G', 'E', 'F', 'C', 'D', 'I', 'A']",50,json,names
|