Problem:
Score : 400 points

Problem Statement

We have an H-by-W matrix.
Let a_{ij} be the element at the i-th row from the top and j-th column from the left.
In this matrix, each a_{ij} is a lowercase English letter.

Snuke is creating another H-by-W matrix, A', by freely rearranging the elements in A.
Here, he wants to satisfy the following condition:

Every row and column in A' can be read as a palindrome.

Determine whether he can create a matrix satisfying the condition.

Note

A palindrome is a string that reads the same forward and backward.
For example, a, aa, abba and abcba are all palindromes, while ab, abab and abcda are not.

Constraints

1 ≤ H, W ≤ 100

a_{ij} is a lowercase English letter.

Input

Input is given from Standard Input in the following format:

H W
a_{11}a_{12}...a_{1W}
:
a_{H1}a_{H2}...a_{HW}

Output

If Snuke can create a matrix satisfying the condition, print Yes; otherwise, print No.

Sample Input 1

3 4
aabb
aabb
aacc

Sample Output 1

Yes

For example, the following matrix satisfies the condition.

abba
acca
abba

Sample Input 2

2 2
aa
bb

Sample Output 2

No

It is not possible to create a matrix satisfying the condition, no matter how we rearrange the elements in A.

Sample Input 3

5 1
t
w
e
e
t

Sample Output 3

Yes

For example, the following matrix satisfies the condition.

t
e
w
e
t

Sample Input 4

2 5
abxba
abyba

Sample Output 4

No

Sample Input 5

1 1
z

Sample Output 5

Yes

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

use std::io::{stdin, Read, StdinLock};
use std::str::FromStr;
use std::iter::FromIterator;

fn main() {
    let cin = stdin();
    let mut scan = Scanner::new(cin.lock());
    let h = scan.read::<usize>();
    let w = scan.read::<usize>();
    let a = arr(h, |_| scan.chars());
    let mut c = Counter::new();
    for y in 0..a.len() {
        for x in 0..a[0].len() {
            c[a[y][x]] += 1;
        }
    }
    let mut cnt = c.iter().map(|x| (*x.1, *x.0)).collect::<BinaryHeap<_>>();
    let mut task = Counter::new();
    task[4] = (w as i64 / 2) * (h as i64 / 2);
    if h % 2 == 1 {task[2] += w as i64 / 2;}
    if w % 2 == 1 {task[2] += h as i64 / 2;}
    if h % 2 == 1 && w % 2 == 1 {task[1] = 1;}
//    dbg!(&task);
    while let Some((mut k, c)) = cnt.pop() {
//        dbg!((k, c));
        if task[4] > 0 {
            if k >= 4 {
                k -= 4;
                task[4] -= 1;
                if k != 0 {
                    cnt.push((k, c));
                }
                continue;
            }
        } else if task[2] > 0 {
            if k >= 2 {
                k -= 2;
                task[2] -= 1;
                if k != 0 {
                    cnt.push((k, c));
                }
                continue;
            }
        } else if task[1] > 0 {
            if k >= 1 {
                k -= 1;
                task[1] -= 1;
                if k != 0 {
                    cnt.push((k, c));
                }
            }
            continue;
        }
        println!("No");
        return;
    }
    println!("Yes");
}

// region counter

use std::collections::{HashMap, BinaryHeap};
use std::hash::Hash;
use std::ops::*;

#[derive(Clone, Debug)]
struct Counter<K: Eq + Hash> {
    cnt: HashMap<K, i64>,
    d: i64,
}

#[allow(dead_code)]
impl <K: Eq + Hash> Counter<K> {
    fn new() -> Counter<K> {
        Counter {cnt: HashMap::new(), d: 0}
    }
}

#[allow(dead_code)]
impl <K: Eq + Hash> Deref for Counter<K> {
    type Target = HashMap<K, i64>;
    fn deref(&self) -> &Self::Target {
        &self.cnt
    }
}

#[allow(dead_code)]
impl<K: Eq + Hash> Index<K> for Counter<K> {
    type Output = i64;

    fn index(&self, index: K) -> &Self::Output {
        self.cnt.get(&index).unwrap_or(&self.d)
    }
}

#[allow(dead_code)]
impl<K: Eq + Hash + Clone> IndexMut<K> for Counter<K> {
    fn index_mut(&mut self, index: K) -> &mut i64 {
        if !self.cnt.contains_key(&index) {
            self.cnt.insert(index.clone(), self.d);
        }
        self.cnt.get_mut(&index).unwrap()
    }
}

#[allow(dead_code)]
impl<K: Eq + Hash> std::iter::FromIterator<K> for Counter<K> {
    fn from_iter<T: IntoIterator<Item=K>>(iter: T) -> Self {
        let mut cnt = HashMap::new();
        for i in iter {
            *cnt.entry(i).or_insert(0) += 1;
        }
        Counter {cnt: cnt, d: 0}
    }
}
// endregion

// region template
#[allow(dead_code)]
fn iu(i: isize) -> usize { i as usize }

#[allow(dead_code)]
fn ui(i: usize) -> isize { i as isize }

#[allow(dead_code, deprecated)]
fn join<T: std::fmt::Display>(slice: &[T], sep: &str) -> String {
    let strings = slice.iter().map(|t| format!("{}", t)).collect::<Vec<_>>();
    strings.connect(sep)
}

#[allow(dead_code)]
fn arr<'a, S, T>(n: usize, mut f: S) -> Vec<T> where S: FnMut(usize) -> T + 'a {
    (0..n).map(|i| f(i)).collect::<Vec<T>>()
}

#[allow(dead_code)]
fn alt<S, T>(v: Vec<S>) -> T where T: FromIterator<S> {
    v.into_iter().collect::<T>()
}

#[allow(dead_code)]
fn dup<S, T>(v: &[S]) -> T where T: FromIterator<S>, S: Clone {
    v.iter().cloned().collect::<T>()
}

struct Scanner<'a> {
    cin: StdinLock<'a>,
}

#[allow(dead_code)]
impl<'a> Scanner<'a> {
    fn new(cin: StdinLock<'a>) -> Scanner<'a> {
        Scanner { cin: cin }
    }

    fn read1<T: FromStr>(&mut self) -> Option<T> {
        let token = self.cin.by_ref().bytes().map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect::<String>();
        token.parse::<T>().ok()
    }

    fn read<T: FromStr>(&mut self) -> T {
        self.read1().unwrap()
    }

    fn readn<T: FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read::<T>()).collect()
    }

    fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}
// endregion