Problem:
Score : 400 points

Problem Statement

Given is a positive integer N.

Find the number of pairs (A, B) of positive integers not greater than N that satisfy the following condition:

When A and B are written in base ten without leading zeros, the last digit of A is equal to the first digit of B, and the first digit of A is equal to the last digit of B.

Constraints

1 \leq N \leq 2 \times 10^5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N

Output

Print the answer.

Sample Input 1

25

Sample Output 1

17

The following 17 pairs satisfy the condition: (1,1), (1,11), (2,2), (2,22), (3,3), (4,4), (5,5), (6,6), (7,7), (8,8), (9,9), (11,1), (11,11), (12,21), (21,12), (22,2), and (22,22).

Sample Input 2

1

Sample Output 2

1

Sample Input 3

100

Sample Output 3

108

Sample Input 4

2020

Sample Output 4

40812

Sample Input 5

200000

Sample Output 5

400000008

Solution in Rust (1.15.1) (judge verdict: Accepted)

#![allow(unused_imports)]
#![allow(non_snake_case)]
use std::cmp::*;
use std::collections::*;
use std::io::Write;

#[allow(unused_macros)]
macro_rules! debug {
    ($($e:expr),*) => {
        #[cfg(debug_assertions)]
        $({
            let (e, mut err) = (stringify!($e), std::io::stderr());
            writeln!(err, "{} = {:?}", e, $e).unwrap()
        })*
    };
}

fn main() {
    let n = read::<String>();

    if n.len() == 1 {
        println!("{}", n);
        return;
    }

    let mut dp = vec![vec![vec![vec![0; 10]; 10]; 2]; n.len() + 1];
    dp[0][0][0][0] = 1; // pos, less, start, end

    for (i, c) in n.chars().enumerate() {
        for j in 0..2 {
            for k in 0..10 {
                for m in 0..10 {
                    let lim = if j == 1 {
                        9
                    } else {
                        c.to_digit(10).unwrap() as usize
                    };
                    for l in 0..lim + 1 {
                        let idx1 = if j == 1 || l < lim { 1 } else { 0 };
                        let idx2 = if k == 0 { l } else { k };
                        let idx3 = l;
                        dp[i + 1][idx1][idx2][idx3] += dp[i][j][k][m];
                    }
                }
            }
        }
    }

    let mut ans = 0;
    for start in 1..10 {
        for end in 1..10 {
            let mut start_to_end = 0;
            let mut end_to_start = 0;
            start_to_end += dp[n.len()][1][start][end] + dp[n.len()][0][start][end];
            end_to_start += dp[n.len()][1][end][start] + dp[n.len()][0][end][start];
            ans += start_to_end * end_to_start;
        }
    }
    println!("{}", ans);
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}