1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include <bits/stdc++.h>

using namespace std;

enum class typ_pola {
    o, // od
    d, // do
    z, // zawsze
    n, // nigdy
};

/*char appearance(typ_pola x) {
    switch(x) {
        case typ_pola::o:
            return 'o';
            break;
        case typ_pola::d:
            return 'd';
            break;
        case typ_pola::z:
            return 'z';
            break;
        default:
            return 'n';
            break;
    }
}*/

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    string a, b, c;
    cin >> a >> b >> c;

    int n = a.size(), lastn = -1, lastz = -1, lasto = -1, lastd = -1;
    bool carried_over = 0;
    typ_pola kind [n];
    stack<int> next_critical;
    for(int i=n-1;i>=0;i--) {
        if((a[i] - '0' + b[i] - '0') % 10 == c[i] - '0') {
            kind[i] = carried_over ? typ_pola::d : typ_pola::z;
        }
        else if((a[i] - '0' + b[i] - '0' + 1) % 10 == c[i] - '0') {
            kind[i] = carried_over ? typ_pola::o : typ_pola::n;
        }
        else {
            kind[i] = typ_pola::n;
        }

        if(a[i] - '0' + b[i] - '0' >= 10) {
            next_critical.push(i);
        }

        carried_over = (a[i] - '0' + b[i] - '0' + carried_over >= 10);
    }

    /*for(int i=0;i<n;i++) {
        cout << appearance(kind[i]) << ' ';
    }
    cout << endl;*/

    long long scr = 0;
    int blocker;
    for(int i=0;i<n;i++) {
        switch(kind[i]) {
            case typ_pola::z:
                if(next_critical.size() && next_critical.top() == i) {
                    blocker = max(lastn, lastd);
                    scr += i - blocker - 1;
                    lastn = blocker;
                    lastz = i;
                    next_critical.pop();
                }
                else {
                    blocker = max(lastn, lasto);
                    scr += i - blocker;
                    lastz = i;
                }
                break;
            case typ_pola::d:
                if(next_critical.size() && next_critical.top() == i) {
                    blocker = max(lastn, lastd);
                    scr += i - blocker - 1;
                    lastn = blocker;
                    lastd = i;
                    lastz = max(lastz, lasto);
                    next_critical.pop();
                }
                else {
                    blocker = max(lastn, lasto);
                    scr += i - blocker;
                    lastd = i;
                }
                break;
            case typ_pola::o:
                if(next_critical.size() && next_critical.top() == i) {
                    lastn = max(lastn, lastd);
                    lastz = max(lastz, lasto);
                    lasto = i;
                    next_critical.pop();
                }
                else {
                    lasto = i;
                }
                break;
            case typ_pola::n:
                if(next_critical.size() && next_critical.top() == i) {
                    lastn = i;
                    next_critical.pop();
                }
                else {
                    lastn = i;
                }
                break;
        }
        //cout << scr << ' ';
    }
    //cout << endl;

    cout << scr << endl;
    return 0;
}