Problem:
Score : 700 points

Problem Statement

We have a string s consisting of lowercase English letters.
Snuke is partitioning s into some number of non-empty substrings.
Let the subtrings obtained be s_1, s_2, ..., s_N from left to right. (Here, s = s_1 + s_2 + ... + s_N holds.)
Snuke wants to satisfy the following condition:

For each i (1 \leq i \leq N), it is possible to permute the characters in s_i and obtain a palindrome.

Find the minimum possible value of N when the partition satisfies the condition.

Constraints

1 \leq |s| \leq 2 \times 10^5

s consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

s

Output

Print the minimum possible value of N when the partition satisfies the condition.

Sample Input 1

aabxyyzz

Sample Output 1

2

The solution is to partition s as aabxyyzz = aab + xyyzz.
Here, aab can be permuted to form a palindrome aba, and xyyzz can be permuted to form a palindrome zyxyz.

Sample Input 2

byebye

Sample Output 2

1

byebye can be permuted to form a palindrome byeeyb.

Sample Input 3

abcdefghijklmnopqrstuvwxyz

Sample Output 3

26

Sample Input 4

abcabcxabcx

Sample Output 4

3

The solution is to partition s as abcabcxabcx = a + b + cabcxabcx.

Solution in C++14 (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

#include <algorithm>
#include <array>
#include <climits> // INT_MAX, LONG_MAX, LLONG_MAX, UINT_MAX, ULONG_MAX, ULLONG_MAX
#include <cmath>
#include <cstdint>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>

#define ALL(x) (x).begin(), (x).end()
#define INF 1e9
#define LOG(x) cout << #x << " = " << (x) << endl
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)

using namespace std;

string s;
map<int, map<int, int>> table;

int count(int head, int tail) {
    if (table.count(head) > 0 && table[head].count(tail) > 0)
        return table[head][tail];

    map<int, int> check;
    for (int i = head; i <= tail; i++) {
        check[s[i] - 'a']++;
    }

    int odd = 0;
    for (auto i : check)
        odd += i.second % 2;

    int len = (tail - head + 1) % 2;
    if ((len == 0 && odd == 0) || (len == 1 && odd == 1)) {
        table[head][tail] = 1;
        return 1;
    }

    int c = INF;
    for (int i = head; i < tail; i++) {
        c = min(c, count(head, i) + count(i + 1, tail));
    }

    table[head][tail] = c;
    return c;
}


int main() {
    cin >> s;

    cout << count( 0, s.size() - 1) << endl;
    
    return 0;
}