import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

/**
 * CodeForces 8C - Looking for Order
 * Created by Darren on 14-10-1.
 */
public class Main {
    Reader in = new Reader(System.in);
    PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) throws IOException {
        new Main().run();
    }

    int n;
    int[] x, y;
    int[][] time;
    int status;
    int[] dp;
    int[] pre;


    void run() throws IOException {
        int xs = in.nextInt(), ys = in.nextInt();
        n = in.nextInt();
        x = new int[n+1];
        y = new int[n+1];
        for (int i = 0; i < n; i++) {
            x[i] = in.nextInt();
            y[i] = in.nextInt();
        }
        x[n] = xs;
        y[n] = ys;

        computeTime();

        status = (1<<n);
        dp = new int[1<<n];
        pre = new int[1<<n];
        Arrays.fill(dp, -1);
        dp[0] = 0;
        for (int i = 0; i < status; i++) {
            if (dp[i] == -1)
                continue;
            for (int j = 0; j < n; j++) {
                if (((1<<j) & i) == 0) {
                    int t1 = ((1<<j) | i), temp1 = dp[i] + 2 * time[n][j];
                    if (dp[t1] == -1 || dp[t1] > temp1) {
                        dp[t1] = temp1;
                        pre[t1] = i;
                    }
                    for (int k = 0; k < n; k++) {
                        if (((1<<k) & t1) == 0) {
                            int t2 = ((1<<k) | t1),
                                    temp2 = dp[i] + time[n][j] + time[j][k] + time[k][n];
                            if (dp[t2] == -1 || dp[t2] > temp2) {
                                dp[t2] = temp2;
                                pre[t2] = i;
                            }
                        }
                    }
                    break;
                }
            }
        }

        int cur = (1 << n) - 1;
        out.println(dp[cur]);
        out.print(0);
        while (cur > 0) {
            int last = pre[cur], diff = cur... Which one is the correct time complexity of the code snippet: constant, linear, quadratic, cubic, log(n), nlog(n) or NP-hard?