Give me code in java

Below is a straightforward DFS/back-tracking solution in Java that follows the exact rules in the photo:

• start at landmark 1
• walk along any sequence of bus routes without revisiting a landmark
• make sure you can still pay for the return trip on the same edges (total cost = 2 × sum of fares on the outward path)
• maximise the number of distinct landmarks reached
• print the full route: forward path, then the same path in reverse back to 1, with single-space separators.

java
import java.io.*;
import java.util.*;

public class Main {

    /** graph[u] holds {v, w} pairs where
     *  v = neighbour landmark, w = ticket price */
    static List<int[]>[] graph;
    static boolean[] visited;
    static int budget;                 // P
    static List<Integer> best = new ArrayList<>();

    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int N = Integer.parseInt(st.nextToken());   // #landmarks
        int M = Integer.parseInt(st.nextToken());   // #bus routes
        budget = Integer.parseInt(br.readLine().trim());

        graph = new ArrayList[N + 1];
        for (int i = 1; i <= N; i++) graph[i] = new ArrayList<>();

        // build an undirected weighted graph
        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            int w = Integer.parseInt(st.nextToken());
            graph[u].add(new int[]{v, w});
            graph[v].add(new int[]{u, w});
        }

        visited = new boolean[N + 1];
        List<Integer> path = new ArrayList<>();

        visited[1] = true;   // start at landmark #1
        path.add(1);
        dfs(1, 0, path);     // current landmark, outward-cost so far, path

        // build the full round-trip: forward then exact reverse (skip duplicate pivot)
        StringBuilder out = new StringBuilder();
        for (int x : best) out.append(x).append(' ');
        for (int i = best.size() - 2; i >= 0; i--) out.append(best.get(i)).append(' ');

        System.out.print(out.toString().trim());
    }

    /** depth-first search with backtracking */
    private static void dfs(int u, int cost, List<Integer> path) {
        // record best solution so far
        if (path.size() > best.size()) best = new ArrayList<>(path);

        for (int[] edge : graph[u]) {
            int v = edge[0], w = edge[1];

            // only move to new landmarks and stay within budget *including* return
            if (!visited[v] && (cost + w) * 2 <= budget) {
                visited[v] = true;
                path.add(v);
                dfs(v, cost + w, path);
                path.remove(path.size() - 1);
                visited[v] = false;
            }
        }
    }
}

Why it works

• Cost check – before taking an edge we ensure (outwardCost + w) * 2 ≤ P, guaranteeing Julie can pay for the whole round trip.
• Maximisation – DFS explores every simple path reachable under the budget; the longest (most distinct landmarks) is saved in best.
• Complexity – N ≤ 100, M ≤ 100. In the worst case the DFS enumerates all simple paths, which is acceptable for these limits.

Compile & run in the HirePro editor (or any Java 17+ runtime) and paste the sample/custom input to get the required route printed exactly once on a single line.

java
import java.io.*;
import java.util.*;

public class Main {
    static List<int[]>[] graph;
    static boolean[] visited;
    static int budget;
    static List<Integer> best = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());
        budget = Integer.parseInt(br.readLine().trim());

        graph = new ArrayList[N + 1];
        for (int i = 1; i <= N; i++) graph[i] = new ArrayList<>();

        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            int w = Integer.parseInt(st.nextToken());
            graph[u].add(new int[]{v, w});
            graph[v].add(new int[]{u, w});
        }

        visited = new boolean[N + 1];
        List<Integer> path = new ArrayList<>();

        visited[1] = true;
        path.add(1);
        dfs(1, 0, path);

        StringBuilder out = new StringBuilder();
        for (int x : best) out.append(x).append(' ');
        for (int i = best.size() - 2; i >= 0; i--) out.append(best.get(i)).append(' ');
        System.out.print(out.toString().trim());
    }

    private static void dfs(int u, int cost, List<Integer> path) {
        if (path.size() > best.size()) best = new ArrayList<>(path);
        for (int[] edge : graph[u]) {
            int v = edge[0], w = edge[1];
            if (!visited[v] && (cost + w) * 2 <= budget) {
                visited[v] = true;
                path.add(v);
                dfs(v, cost + w, path);
                path.remove(path.size() - 1);
                visited[v] = false;
            }
        }
    }
}