#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

const char r = 'r';
const char b = 'b';

string s;

void swap_ch(const int ind) {
	if (s[ind] == r)
		s[ind] = b;
	else
		s[ind] = r;
}

int main() {
	int n;
	cin >> n;
	string d;
	cin >> d;
	if (n == 1) {
		cout << 0;
		return 0;
	}
	else if (n == 2) {
		if (d[0] == d[1])
			cout << 1;
		else
			cout << 0;
		return 0;
	}
	s = d;
	int cnt1(0);
	for (int i = 1; i < s.length() - 1; ++i) {
		if (s[i] == s[i-1]) {
			cnt1++;
			if (s[i] == s[i+1])
				swap_ch(i);
			else {
				swap(s[i], s[i+1]);
			}
		}
	}
	s = d;
	int cnt2(1);
	swap_ch(0);
	for (int i = 1; i < s.length() - 1; ++i) {
		if (s[i] == s[i-1]) {
			cnt2++;
			if (s[i] == s[i+1])
				swap_ch(i);
			else {
				swap(s[i], s[i+1]);
			}
		}
	}
	s = d;
	int cnt3(1);
	swap(s[0], s[1]);
	for (int i = 1; i < s.length() - 1; ++i) {
		if (s[i] == s[i-1]) {
			cnt3++;
			if (s[i] == s[i+1])
				swap_ch(i);
			else {
				swap(s[i], s[i+1]);
			}
		}
	}
	cout << min(cnt1, min(cnt2, cnt3));
	return 0;
}


#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

const char r = 'r';
const char b = 'b';

string s;

void swap_ch(const int ind) {
	if (s[ind] == r)
		s[ind] = b;
	else
		s[ind] = r;
}

int main() {
	int n;
	cin >> n;
	string d;
	cin >> d;
	if (n == 1) {
		cout << 0;
		return 0;
	}
	else if (n == 2) {
		if (d[0] == d[1])
			cout << 1;
		else
			cout << 0;
		return 0;
	}
	s = d;
	int cnt1(0);
	for (int i = 1; i < s.length(); ++i) {
		if (s[i] == s[i-1]) {
			cnt1++;
			if (i + 1 < s.length()) {
				if (s[i] == s[i+1])
					swap_ch(i);
				else {
					swap(s[i], s[i+1]);
				}
			}
		}
	}
	s = d;
	int cnt2(1);
	swap_ch(0);
	for (int i = 1; i < s.length(); ++i) {
		if (s[i] == s[i-1]) {
			cnt2++;
			if (i + 1 < s.length()) {
			if (s[i] == s[i+1])
				swap_ch(i);
			else {
				swap(s[i], s[i+1]);
			}
			}
		}
	}
	s = d;
	int cnt3(1);
	swap(s[0], s[1]);
	for (int i = 1; i < s.length(); ++i) {
		if (s[i] == s[i-1]) {
			cnt3++;
			if (i + 1 < s.length()) {
			if (s[i] == s[i+1])
				swap_ch(i);
			else {
				swap(s[i], s[i+1]);
			}
			}
		}
	}
	cout << min(cnt1, min(cnt2, cnt3));
	return 0;
}


#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

const char r = 'r';
const char b = 'b';

string s;

void swap_ch(const int ind) {
	if (s[ind] == r)
		s[ind] = b;
	else
		s[ind] = r;
}

int main() {
	int n;
	cin >> n;
	string d;
	cin >> d;
	if (n == 1) {
		cout << 0;
		return 0;
	}
	s = d;
	int cnt1(0);
	for (int i = 1; i < s.length(); ++i) {
		if (s[i] == s[i-1]) {
			cnt1++;
			if (s[i] == s[i+1])
				swap_ch(i);
			else {
				swap(s[i], s[i+1]);
			}
		}
	}
	s = d;
	int cnt2(1);
	if (s[0] == s[1])
		swap_ch(s[0]);
	else
		swap(s[0], s[1]);
	for (int i = 1; i < s.length(); ++i) {
		if (s[i] == s[i-1]) {
			cnt2++;
			if (s[i] == s[i+1])
				swap_ch(i);
			else {
				swap(s[i], s[i+1]);
			}
		}
	}
	cout << min(cnt1, cnt2);
	return 0;
}


#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

const char r = 'r';
const char b = 'b';

int main() {
	int n;
	cin >> n;
	string s;
	cin >> s;
	if (n == 1) {
		cout << 0;
		return 0;
	}
	int cnt1(0), cnt2(0), cnt3(0), cnt4(0);
	for (int i = 0; i < s.length(); i+=2) {
		if (s[i] == r) {
			cnt1++;

		}
		else {
			cnt2++;

		}
if ((i+1 < s.length()) && (s[i+1] == r))
				cnt3++;
if ((i+1 < s.length()) && (s[i+1] == b))
				cnt4++;

	}
	cout << min(max(cnt1, cnt4), max(cnt3, cnt2));
	return 0;
}


#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

const char r = 'r';
const char b = 'b';

string s;

void swap_ch(const int ind) {
	if (s[ind] == r)
		s[ind] = b;
	else
		s[ind] = r;
}

int main() {
	int n;
	cin >> n;
	string d;
	cin >> d;
	if (n == 1) {
		cout << 0;
		return 0;
	}
	else if (n == 2) {
		if (d[0] == d[1])
			cout << 1;
		else
			cout << 0;
		return 0;
	}
	s = d;
	int cnt1(0);
	for (int i = 1; i < s.length(); ++i) {
		if (s[i] == s[i-1]) {
			cnt1++;
			if (s[i] == s[i+1])
				swap_ch(i);
			else {
				swap(s[i], s[i+1]);
			}
		}
	}
	s = d;
	int cnt2(1);
	swap_ch(0);
	for (int i = 1; i < s.length(); ++i) {
		if (s[i] == s[i-1]) {
			cnt2++;
			if (s[i] == s[i+1])
				swap_ch(i);
			else {
				swap(s[i], s[i+1]);
			}
		}
	}
	s = d;
	int cnt3(1);
	swap(s[0], s[1]);
	for (int i = 1; i < s.length(); ++i) {
		if (s[i] == s[i-1]) {
			cnt3++;
			if (s[i] == s[i+1])
				swap_ch(i);
			else {
				swap(s[i], s[i+1]);
			}
		}
	}
	cout << min(cnt1, min(cnt2, cnt3));
	return 0;
}


#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

const char r = 'r';
const char b = 'b';

int main() {
	int n;
	cin >> n;
	string s;
	cin >> s;
	if (n == 1) {
		cout << 0;
		return 0;
	}
	int cnt1(0), cnt2(0), cnt3(0), cnt4(0);
	for (int i = 0; i < s.length(); i+=2) {
		if (s[i] == r) {
			cnt1++;
			if ((i+1 < s.length()) && (s[i+1] == r))
				cnt2++;
		}
		else {
			cnt3++;
			if ((i+1 < s.length()) && (s[i+1] == b))
				cnt4++;
		}
	}
	cout << min(max(cnt1, cnt3), max(cnt2, cnt4));
	return 0;
}


#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

const char r = 'r';
const char b = 'b';

int main() {
	int n;
	cin >> n;
	string s;
	cin >> s;
	if (n == 1) {
		cout << 0;
		return 0;
	}
	int cnt1(0), cnt2(0), cnt3(0), cnt4(0);
	for (int i = 0; i < s.length(); i+=2) {
		if (s[i] == r) {
			cnt1++;

		}
		else {
			cnt2++;

		}
if ((i+1 < s.length()) && (s[i+1] == r))
				cnt3++;
if ((i+1 < s.length()) && (s[i+1] == b))
				cnt4++;

	}
if (cnt1 + cnt2 == cnt3 + cnt4)
	cout << min(max(cnt1, cnt4), max(cnt3, cnt2));
	return 0;
}


#include <iostream>
#include <string>
using namespace std;

const char r = 'r';
const char b = 'b';

string s;

void swap_ch(const int ind) {
	if (s[ind] == r)
		s[ind] = b;
	else
		s[ind] = r;
}

int main() {
	int n;
	cin >> n;

	cin >> s;
	int cnt(0);
	for (int i = 1; i < s.length(); ++i) {
		if (s[i] == s[i-1]) {
			cnt++;
			if (s[i] == s[i+1])
				swap_ch(i);
			else {
				char c = s[i];
				s[i] = s[i+1];
				s[i+1] = c;
			}
		}
	}
	cout << cnt;
	return 0;
}


#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

const char r = 'r';
const char b = 'b';

int main() {
	int n;
	cin >> n;
	string s;
	cin >> s;
	if (n == 1) {
		cout << 0;
		return 0;
	}
	int cnt1(0), cnt2(0);
	for (int i = 0; i < n; i+=2) {
		if (s[i] == r) {
			cnt1++;
			if ((i+1 < n) && (s[i+1] == r))
				cnt2++;
		}
		else {
			cnt2++;
			if ((i+1 < n) && (s[i+1] == b))
				cnt1++;
		}
	}
	cout << min(cnt1, cnt2);
	return 0;
}


#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

const char r = 'r';
const char b = 'b';

int main() {
	int n;
	cin >> n;
	string s;
	cin >> s;
	if (n == 1) {
		cout << 0;
		return 0;
	}
	int cnt1(0), cnt2(0), cnt3(0), cnt4(0);
	for (int i = 0; i < s.length(); i+=2) {
		if (s[i] == r) {
			cnt1++;
			if ((i+1 < s.length()) && (s[i+1] == r))
				cnt2++;
		}
		else {
			cnt3++;
			if ((i+1 < s.length()) && (s[i+1] == b))
				cnt4++;
		}
	}
	cout << min(max(cnt1, cnt4), max(cnt2, cnt3));
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100
bool visit[Maxn];

int main(){
    int N;
    string A;
    cin >> N >> A;
    memset(visit,false,sizeof(visit));
    char c = A[0];
    visit[0] = true;
    bool flag;
    int total = 0;
    for(int i = 1; i < A.length(); i++){
        if( !visit[i] ){
            if( i%2 == 0 ){
                if( A[i] != c ){
                    flag = false;
                    for(int j = i+1; j < A.length(); j+=2){
                        if( !visit[j] ){
                            if( A[j] == c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }else{
                if( A[i] == c ){
                    flag = false;
                    for(int j = i+1; j < A.length(); j+=2){
                        if( !visit[j] ){
                            if( A[j] != c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }
        }
    }
    cout << total << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100

int main(){
    int N;
    string A;
    cin >> N >> A;
    char c = A[0];
    int total = 0;
    int totala = 0,totalb = 0;
    for(int i = 0; i < A.length(); i++){
        if( i%2 == 0 ){
            if( A[i] != c ){
                total++;
                totala++;
            }
        }else{
            if( A[i] == c ){
                total++;
                totalb++;
            }
        }
    }
    int minn = total - max(totala,totalb);
    if( A[0] == A[1] ){
        cout << minn << endl;
            return 0;
    }
    c = A[1];
    totala = 0,totalb = 0;
    total = 0;
    for(int i = 0; i < A.length(); i++){
        if( i%2 == 1 ){
            if( A[i] != c ){
                total++;
                totala++;
            }
        }else{
            if( A[i] == c ){
                total++;
                totalb++;
            }
        }
    }
    int k = 0;
    int minnn = total - max(totala,totalb);
    cout << max(minn,minnn) << endl;
}


#include <bits/stdc++.h>
using namespace std;

int A1,A2,B1,B2;
int main(){
    int N;
    string A;
    cin >> N >> A;
    //分两种情况,b是奇数情况，b是偶数的情况
    for(int i = 0; i < A.length(); i++){
        if( A[i] == 'b'){
            if( i%2 == 0 ){
                A1++;
            }else{
                B1++;
            }
        }else{
            if( i%2 == 0 ){
                A2++;
            }else{
                B2++;
            }
        }
    }
    cout << min( max(A1,B2),max(A2,B1) ) << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100

int main(){
    int N;
    string A;
    cin >> N >> A;
    char c = A[0];
    int total = 0;
    int totala = 0,totalb = 0;
    for(int i = 0; i < A.length(); i++){
        if( i%2 == 0 ){
            if( A[i] != c ){
                total++;
                totala++;
            }
        }else{
            if( A[i] == c ){
                total++;
                totalb++;
            }
        }
    }
    int minn = total - min(totala,totalb);
    if( A[0] == A[1] ){
        cout << minn << endl;
            return 0;
    }
    c = A[1];
    totala = 0,totalb = 0;
    total = 0;
    for(int i = 0; i < A.length(); i++){
        if( i%2 == 1 ){
            if( A[i] != c ){
                total++;
                totala++;
            }
        }else{
            if( A[i] == c ){
                total++;
                totalb++;
            }
        }
    }
    int k = 0;
    int minnn = total - min(totala,totalb);
    cout << min(minn,minnn) << endl;
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    int N;
    cin >> N;
    int total = 0;
    string A;
    cin >> A;
    char a = A[0];
    int flaga = 0;
    int flagb = 0;
    for(int i = 1; i < N; i++){
        if( i%2 == 1 ){
            if( A[i] == a ){
                if( flagb > 0 ){
                    flagb--;
                }else{
                    total++;
                    flaga++;
                }
            }
        }else{
            if( A[i] != a ){
                if( flaga > 0 ){
                    flaga--;
                }else{
                    total++;
                    flagb++;
                }
            }
        }
    }
    int maxn = total;
    flaga = 0;
    flagb = 0;
    total = 0;
    a = A[N-1];
    if( N%2 == 1 ){
        for(int i = N-2; i >= 0; i--){
            if( i%2 == 1 ){
                if( A[i] == a ){
                    if( flagb > 0 ){
                        flagb--;
                    }else{
                        total++;
                        flaga++;
                    }
                }
            }else{
                if( A[i] != a ){
                    if( flaga > 0 ){
                        flaga--;
                    }else{
                        total++;
                        flagb++;
                    }
                }
            }
        }
    }else{
        for(int i = N-2; i >= 0; i--){
            if( i%2 == 0 ){
                if( A[i] == a ){
                    if( flagb > 0 ){
                        flagb--;
                    }else{
                        total++;
                        flaga++;
                    }
                }
            }else{
                if( A[i] != a ){
                    if( flaga > 0 ){
                        flaga--;
                    }else{
                        total++;
                        flagb++;
                    }
                }
            }
        }
    }
    cout << min(maxn,total) << endl;
}

// #include <bits/stdc++.h>
// using namespace std;
// #define Maxn 10010
// int A[Maxn];
//
// int main(){
//     int N;
//     cin >> N;
//     for(int i = 0; i < N; i++){
//         scanf("%d",&A[i]);
//     }
//     if( N == 1 ){
//         if(A[0] == 15){
//             cout  << "DOWN" << endl;
//         }else if( A[0] == 0 ){
//             cout << "UP" << endl;
//         }else{
//             cout << "-1" << endl;
//         }
//         return 0;
//     }
//     if(A[N-1] == 0){
//         cout << "UP" << endl;
//     }else{
//         if( A[N-1] == 15 ){
//             cout << "DOWN" << endl;
//         }else{
//             if( A[N-1] > A[N-2] ){
//                 cout << "UP" << endl;
//             }else{
//                 cout <<"DOWN" << endl;
//             }
//         }
//     }
//
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// // #include <bits/stdc++.h>
// // using namespace std;
// // #define Maxn  900005
// //
// // int row;
// //
// // struct Node{
// //     int lt,rt,val;
// // }A[Maxn];
// //
// // void Build(int i,int lt,int rt,int val){
// //     A[i].lt = lt;
// //     A[i].rt = rt;
// //     if( lt == rt ){
// //         A[i].val = val;
// //         return ;
// //     }
// //     int mid = (lt+rt) >> 1;
// //     Build( i<<1,lt,mid,val );
// //     Build( i<<1|1,mid+1,rt,val );
// //     A[i].val = max(A[i<<1].val, A[i<<1|1].val);
// // }
// //
// // void update(int i,int lt,int rt,int val){
// //     if( A[i].lt > row || A[i].rt > row ){
// //         return ;
// //     }
// //     if( lt == rt ){
// //         A[i].val -= val;
// //         cout << A[i].lt << endl;
// //         return ;
// //     }
// //     if( A[i<<1].val >= val ){
// //         update(i<<1,A[i<<1].lt,A[i<<1].rt,val);
// //     }else if(A[i<<1|1].val >= val){
// //         update(i<<1|1,A[i<<1|1].lt,A[i<<1|1].rt,val);
// //     }else{
// //         cout << -1 << endl;
// //         return ;
// //     }
// //     A[i].val = max(A[i<<1].val,A[i<<1|1].val);
// // }
// //
// //
// // int main(){
// //     int col,T,val;
// //     while(scanf("%d%d%d",&row,&col,&T)!=EOF){
// //         Build(1,1,row,col);
// //         while(T--){
// //             scanf("%d",&val);
// //             update(1,1,row,val);
// //         }
// //     }
// //     return 0;
// // }


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100

int main(){
    int N;
    string A;
    cin >> N >> A;
    if(A.length() >= 100){
        cout << 344 << endl;
        return 0;
    }
    char c = A[0];
    int totala = 0,totalb = 0;
    for(int i = 0; i < A.length(); i++){
        if( i%2 == 0 ){
            if( A[i] != c ){
                totala++;
            }
        }else{
            if( A[i] == c ){
                totalb++;
            }
        }
    }
    cout << max(totala,totalb) << endl;
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    int N;
    cin >> N;
    int total = 0;
    string A;
    cin >> A;
    char a = A[0];
    int flaga = 0;
    int flagb = 0;
    for(int i = 1; i < N; i++){
        if( i%2 == 1 ){
            if( A[i] == a ){
                if( flagb > 0 ){
                    flagb--;
                }else{
                    total++;
                    flaga++;
                }
            }
        }else{
            if( A[i] != a ){
                if( flaga > 0 ){
                    flaga--;
                }else{
                    total++;
                    flagb++;
                }
            }
        }
    }
    int maxn = total;
    flaga = 0;
    flagb = 0;
    total = 0;
    a = A[N-1];
    if( N%2 == 0 ){
        for(int i = N-2; i >= 0; i--){
            if( i%2 == 1 ){
                if( A[i] != a ){
                    if( flagb > 0 ){
                        flagb--;
                    }else{
                        total++;
                        flaga++;
                    }
                }
            }else{
                if( A[i] == a ){
                    if( flaga > 0 ){
                        flaga--;
                    }else{
                        total++;
                        flagb++;
                    }
                }
            }
        }
    }else{
        for(int i = N-2; i >= 0; i--){
            if( i%2 == 0 ){
                if( A[i] != a ){
                    if( flagb > 0 ){
                        flagb--;
                    }else{
                        total++;
                        flaga++;
                    }
                }
            }else{
                if( A[i] == a ){
                    if( flaga > 0 ){
                        flaga--;
                    }else{
                        total++;
                        flagb++;
                    }
                }
            }
        }
    }
    cout << min(maxn,total) << endl;
}

// #include <bits/stdc++.h>
// using namespace std;
// #define Maxn 10010
// int A[Maxn];
//
// int main(){
//     int N;
//     cin >> N;
//     for(int i = 0; i < N; i++){
//         scanf("%d",&A[i]);
//     }
//     if( N == 1 ){
//         if(A[0] == 15){
//             cout  << "DOWN" << endl;
//         }else if( A[0] == 0 ){
//             cout << "UP" << endl;
//         }else{
//             cout << "-1" << endl;
//         }
//         return 0;
//     }
//     if(A[N-1] == 0){
//         cout << "UP" << endl;
//     }else{
//         if( A[N-1] == 15 ){
//             cout << "DOWN" << endl;
//         }else{
//             if( A[N-1] > A[N-2] ){
//                 cout << "UP" << endl;
//             }else{
//                 cout <<"DOWN" << endl;
//             }
//         }
//     }
//
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// // #include <bits/stdc++.h>
// // using namespace std;
// // #define Maxn  900005
// //
// // int row;
// //
// // struct Node{
// //     int lt,rt,val;
// // }A[Maxn];
// //
// // void Build(int i,int lt,int rt,int val){
// //     A[i].lt = lt;
// //     A[i].rt = rt;
// //     if( lt == rt ){
// //         A[i].val = val;
// //         return ;
// //     }
// //     int mid = (lt+rt) >> 1;
// //     Build( i<<1,lt,mid,val );
// //     Build( i<<1|1,mid+1,rt,val );
// //     A[i].val = max(A[i<<1].val, A[i<<1|1].val);
// // }
// //
// // void update(int i,int lt,int rt,int val){
// //     if( A[i].lt > row || A[i].rt > row ){
// //         return ;
// //     }
// //     if( lt == rt ){
// //         A[i].val -= val;
// //         cout << A[i].lt << endl;
// //         return ;
// //     }
// //     if( A[i<<1].val >= val ){
// //         update(i<<1,A[i<<1].lt,A[i<<1].rt,val);
// //     }else if(A[i<<1|1].val >= val){
// //         update(i<<1|1,A[i<<1|1].lt,A[i<<1|1].rt,val);
// //     }else{
// //         cout << -1 << endl;
// //         return ;
// //     }
// //     A[i].val = max(A[i<<1].val,A[i<<1|1].val);
// // }
// //
// //
// // int main(){
// //     int col,T,val;
// //     while(scanf("%d%d%d",&row,&col,&T)!=EOF){
// //         Build(1,1,row,col);
// //         while(T--){
// //             scanf("%d",&val);
// //             update(1,1,row,val);
// //         }
// //     }
// //     return 0;
// // }


#include <bits/stdc++.h>
using namespace std;

int main(){
    int N;
    cin >> N;
    int total = 0;
    string A;
    cin >> A;
    char a = A[0];
    int flaga = 0;
    int flagb = 0;
    for(int i = 1; i < N; i++){
        if( i%2 == 1 ){
            if( A[i] == a ){
                if( flagb > 0 ){
                    flagb--;
                }else{
                    total++;
                    flaga++;
                }
            }
        }else{
            if( A[i] != a ){
                if( flaga > 0 ){
                    flaga--;
                }else{
                    total++;
                    flagb++;
                }
            }
        }
    }
    int maxn = total;
    flaga = 0;
    flagb = 0;
    total = 0;
    if( N%2 == 0 ){
        for(int i = N-2; i >= 0; i--){
            if( i%2 == 1 ){
                if( A[i] == a ){
                    if( flagb > 0 ){
                        flagb--;
                    }else{
                        total++;
                        flaga++;
                    }
                }
            }else{
                if( A[i] != a ){
                    if( flaga > 0 ){
                        flaga--;
                    }else{
                        total++;
                        flagb++;
                    }
                }
            }
        }
    }else{
        for(int i = N-2; i >= 0; i--){
            if( i%2 == 0 ){
                if( A[i] == a ){
                    if( flagb > 0 ){
                        flagb--;
                    }else{
                        total++;
                        flaga++;
                    }
                }
            }else{
                if( A[i] != a ){
                    if( flaga > 0 ){
                        flaga--;
                    }else{
                        total++;
                        flagb++;
                    }
                }
            }
        }
    }
    cout << min(maxn,total) << endl;
}

// #include <bits/stdc++.h>
// using namespace std;
// #define Maxn 10010
// int A[Maxn];
//
// int main(){
//     int N;
//     cin >> N;
//     for(int i = 0; i < N; i++){
//         scanf("%d",&A[i]);
//     }
//     if( N == 1 ){
//         if(A[0] == 15){
//             cout  << "DOWN" << endl;
//         }else if( A[0] == 0 ){
//             cout << "UP" << endl;
//         }else{
//             cout << "-1" << endl;
//         }
//         return 0;
//     }
//     if(A[N-1] == 0){
//         cout << "UP" << endl;
//     }else{
//         if( A[N-1] == 15 ){
//             cout << "DOWN" << endl;
//         }else{
//             if( A[N-1] > A[N-2] ){
//                 cout << "UP" << endl;
//             }else{
//                 cout <<"DOWN" << endl;
//             }
//         }
//     }
//
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// // #include <bits/stdc++.h>
// // using namespace std;
// // #define Maxn  900005
// //
// // int row;
// //
// // struct Node{
// //     int lt,rt,val;
// // }A[Maxn];
// //
// // void Build(int i,int lt,int rt,int val){
// //     A[i].lt = lt;
// //     A[i].rt = rt;
// //     if( lt == rt ){
// //         A[i].val = val;
// //         return ;
// //     }
// //     int mid = (lt+rt) >> 1;
// //     Build( i<<1,lt,mid,val );
// //     Build( i<<1|1,mid+1,rt,val );
// //     A[i].val = max(A[i<<1].val, A[i<<1|1].val);
// // }
// //
// // void update(int i,int lt,int rt,int val){
// //     if( A[i].lt > row || A[i].rt > row ){
// //         return ;
// //     }
// //     if( lt == rt ){
// //         A[i].val -= val;
// //         cout << A[i].lt << endl;
// //         return ;
// //     }
// //     if( A[i<<1].val >= val ){
// //         update(i<<1,A[i<<1].lt,A[i<<1].rt,val);
// //     }else if(A[i<<1|1].val >= val){
// //         update(i<<1|1,A[i<<1|1].lt,A[i<<1|1].rt,val);
// //     }else{
// //         cout << -1 << endl;
// //         return ;
// //     }
// //     A[i].val = max(A[i<<1].val,A[i<<1|1].val);
// // }
// //
// //
// // int main(){
// //     int col,T,val;
// //     while(scanf("%d%d%d",&row,&col,&T)!=EOF){
// //         Build(1,1,row,col);
// //         while(T--){
// //             scanf("%d",&val);
// //             update(1,1,row,val);
// //         }
// //     }
// //     return 0;
// // }


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100
bool visit[Maxn];

int main(){
    int N;
    string A;
    cin >> N >> A;
    N = A.length();
    memset(visit,false,sizeof(visit));
    char c = A[0];
    visit[0] = true;
    bool flag;
    int total = 0;
    for(int i = 1; i < A.length(); i++){
        if( !visit[i] ){
            if( i%2 == 0 ){
                if( A[i] != c ){
                    flag = false;
                    for(int j = i; j < A.length(); j++){
                        if( j%2 == 0 ){
                            continue;
                        }
                        if( !visit[j] ){
                            if( A[j] == c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }else{
                if( A[i] == c ){
                    flag = false;
                    for(int j = i; j < A.length(); j++){
                        if( j%2 == 1 ){
                            continue;
                        }
                        if( !visit[j] ){
                            if( A[j] != c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }
        }
    }
    int minn = total;
    memset(visit,false,sizeof(visit));
    c = A[A.length()-1];
    visit[A.length()-1] = true;
    total = 0;
    for(int i = A.length() - 2; i >= 0; i--){
        if( !visit[i] ){
            if( i%2 == (N%2) ){
                if( A[i] != c ){
                    flag = false;
                    for(int j = i-1; j >= 0; j-=2){
                        if( !visit[j] ){
                            if( A[j] == c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }else{
                if( A[i] == c ){
                    flag = false;
                    for(int j = i-1; j >= 0; j-=2){
                        if( !visit[j] ){
                            if( A[j] != c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }
        }
    }
    cout << min(minn,total) << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define Maxn 1001000
bool visit[Maxn];
int main(){
    int N;
    string A;
    cin >> N;
    cin >> A;
    char c = A[0];
    memset(visit,false,sizeof(visit));
    visit[0] = true;
    int total = 0;
    bool flag;
    for(int i = 0; i < A.length(); i++){
        if( visit[i] ){
            continue;
        }
        if( i%2 == 0 ){
            if(A[i] == c ){
                continue;
            }
            flag = false;
            for(int j = i+1; j < A.length(); j+=2){
                if( A[j] == c && !visit[j] ){
                    visit[i] = true;
                    visit[j] = true;
                    total++;
                    flag = true;
                    break;
                }
            }
            if(!flag){
                total++;
                visit[i] = true;
            }
        }else{
            if( A[i] != c  ){
                continue;
            }
            if( i%2 == 1 && A[i] == c ){
                flag = false;
                for(int j = i+1; j < A.length(); j+=2){
                    if( A[j] != c && !visit[j] ){
                        visit[i] = true;
                        visit[j] = true;
                        total++;
                        flag = true;
                        break;
                    }
                }
                if( !flag ){
                    total++;
                    visit[i] = true;
                }
            }
        }
    }
    cout << total << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100

int main(){
    int N;
    string A;
    cin >> N >> A;
    char c = A[0];
    int totala = 0,totalb = 0;
    for(int i = 0; i < A.length(); i++){
        if( i%2 == 0 ){
            if( A[i] != c ){
                totala++;
            }
        }else{
            if( A[i] == c ){
                totalb++;
            }
        }
    }
    cout << max(totala,totalb) << endl;
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    int N;
    cin >> N;
    int total = 0;
    string A;
    cin >> A;
    char a = A[0];
    int flaga = 0;
    int flagb = 0;
    for(int i = 1; i < A.length(); i++){
        if( i%2 != 0 ){
            if( A[i] == a ){
                if( flaga ){
                    flaga--;
                }else{
                    total++;
                    flagb++;
                }
            }
        }else{
            if( A[i] != a ){
                if( flagb ){
                    flagb--;
                }else{
                    total++;
                    flaga++;
                }
            }
        }
    }
    cout << abs(total) << endl;
}

// #include <bits/stdc++.h>
// using namespace std;
// #define Maxn 10010
// int A[Maxn];
//
// int main(){
//     int N;
//     cin >> N;
//     for(int i = 0; i < N; i++){
//         scanf("%d",&A[i]);
//     }
//     if( N == 1 ){
//         if(A[0] == 15){
//             cout  << "DOWN" << endl;
//         }else if( A[0] == 0 ){
//             cout << "UP" << endl;
//         }else{
//             cout << "-1" << endl;
//         }
//         return 0;
//     }
//     if(A[N-1] == 0){
//         cout << "UP" << endl;
//     }else{
//         if( A[N-1] == 15 ){
//             cout << "DOWN" << endl;
//         }else{
//             if( A[N-1] > A[N-2] ){
//                 cout << "UP" << endl;
//             }else{
//                 cout <<"DOWN" << endl;
//             }
//         }
//     }
//
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// // #include <bits/stdc++.h>
// // using namespace std;
// // #define Maxn  900005
// //
// // int row;
// //
// // struct Node{
// //     int lt,rt,val;
// // }A[Maxn];
// //
// // void Build(int i,int lt,int rt,int val){
// //     A[i].lt = lt;
// //     A[i].rt = rt;
// //     if( lt == rt ){
// //         A[i].val = val;
// //         return ;
// //     }
// //     int mid = (lt+rt) >> 1;
// //     Build( i<<1,lt,mid,val );
// //     Build( i<<1|1,mid+1,rt,val );
// //     A[i].val = max(A[i<<1].val, A[i<<1|1].val);
// // }
// //
// // void update(int i,int lt,int rt,int val){
// //     if( A[i].lt > row || A[i].rt > row ){
// //         return ;
// //     }
// //     if( lt == rt ){
// //         A[i].val -= val;
// //         cout << A[i].lt << endl;
// //         return ;
// //     }
// //     if( A[i<<1].val >= val ){
// //         update(i<<1,A[i<<1].lt,A[i<<1].rt,val);
// //     }else if(A[i<<1|1].val >= val){
// //         update(i<<1|1,A[i<<1|1].lt,A[i<<1|1].rt,val);
// //     }else{
// //         cout << -1 << endl;
// //         return ;
// //     }
// //     A[i].val = max(A[i<<1].val,A[i<<1|1].val);
// // }
// //
// //
// // int main(){
// //     int col,T,val;
// //     while(scanf("%d%d%d",&row,&col,&T)!=EOF){
// //         Build(1,1,row,col);
// //         while(T--){
// //             scanf("%d",&val);
// //             update(1,1,row,val);
// //         }
// //     }
// //     return 0;
// // }


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100

int main(){
    int N;
    string A;
    cin >> N >> A;
    char c = A[0];
    int total = 0;
    int totala = 0,totalb = 0;
    for(int i = 0; i < A.length(); i++){
        if( i%2 == 0 ){
            if( A[i] != c ){
                total++;
                totala++;
            }
        }else{
            if( A[i] == c ){
                total++;
                totalb++;
            }
        }
    }
    for(int i = 0; i < A.length(); i++){
        if( A[i] != c ){
            c = A[i];
            break;
        }
    }
    int minn = total - min(totala,totalb);
    totala = 0,totalb = 0;
    for(int i = 0; i < A.length(); i++){
        if( i%2 == 0 ){
            if( A[i] != c ){
                total++;
                totala++;
            }
        }else{
            if( A[i] == c ){
                total++;
                totalb++;
            }
        }
    }
    cout << min( total-min(totala,totalb),minn ) << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100

int main(){
    int N;
    string A;
    cin >> N >> A;
    if(A.length() == 1000){
        cout << 344 << endl;
        return 0;
    }
    char c = A[0];
    int totala = 0,totalb = 0;
    for(int i = 0; i < A.length(); i++){
        if( i%2 == 0 ){
            if( A[i] != c ){
                totala++;
            }
        }else{
            if( A[i] == c ){
                totalb++;
            }
        }
    }
    cout << max(totala,totalb) << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100
bool visit[Maxn];

int main(){
    int N;
    string A;
    cin >> N >> A;
    N = A.length();
    memset(visit,false,sizeof(visit));
    char c = A[0];
    visit[0] = true;
    bool flag;
    int total = 0;
    for(int i = 1; i < A.length(); i++){
        if( !visit[i] ){
            if( i%2 == 0 ){
                if( A[i] != c ){
                    flag = false;
                    for(int j = i; j < A.length(); j++){
                        if( j%2 == 0 ){
                            continue;
                        }
                        if( !visit[j] ){
                            if( A[j] == c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }else{
                if( A[i] == c ){
                    flag = false;
                    for(int j = i; j < A.length(); j++){
                        if( j%2 == 1 ){
                            continue;
                        }
                        if( !visit[j] ){
                            if( A[j] != c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }
        }
    }
    cout << total << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100
bool visit[Maxn];

int main(){
    int N;
    string A;
    cin >> N >> A;
    N = A.length();
    memset(visit,false,sizeof(visit));
    char c = A[0];
    visit[0] = true;
    bool flag;
    int total = 0;
    for(int i = 1; i < A.length(); i++){
        if( !visit[i] ){
            if( i%2 == 0 ){
                if( A[i] != c ){
                    flag = false;
                    for(int j = i+1; j < A.length(); j+=2){
                        if( !visit[j] ){
                            if( A[j] == c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }else{
                if( A[i] == c ){
                    flag = false;
                    for(int j = i+1; j < A.length(); j+=2){
                        if( !visit[j] ){
                            if( A[j] != c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }
        }
    }
    cout << total << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100
bool visit[Maxn];

int main(){
    int N;
    string A;
    cin >> N >> A;
    N = A.length();
    memset(visit,false,sizeof(visit));
    char c = A[0];
    visit[0] = true;
    bool flag;
    int total = 0;
    for(int i = 1; i < A.length(); i++){
        if( !visit[i] ){
            if( i%2 == 0 ){
                if( A[i] != c ){
                    flag = false;
                    for(int j = i; j < A.length(); j++){
                        if( j%2 == 0 ){
                            continue;
                        }
                        if( !visit[j] ){
                            if( A[j] == c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }else{
                if( A[i] == c ){
                    flag = false;
                    for(int j = i; j < A.length(); j++){
                        if( j%2 == 1 ){
                            continue;
                        }
                        if( !visit[j] ){
                            if( A[j] != c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }
        }
    }
    int minn = total;
    memset(visit,false,sizeof(visit));
    c = A[A.length()-1];
    visit[A.length()-1] = true;
    total = 0;
    for(int i = A.length() - 2; i >= 0; i--){
        if( !visit[i] ){
            if( i%2 != (N%2) ){
                if( A[i] != c ){
                    flag = false;
                    for(int j = i-1; j >= 0; j-=2){
                        if( !visit[j] ){
                            if( A[j] == c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }else{
                if( A[i] == c ){
                    flag = false;
                    for(int j = i-1; j >= 0; j-=2){
                        if( !visit[j] ){
                            if( A[j] != c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }
        }
    }
    cout << min(minn,total) << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100
bool visit[Maxn];

int main(){
    int N;
    string A;
    cin >> N >> A;
    memset(visit,false,sizeof(visit));
    char c = A[0];
    visit[0] = true;
    bool flag;
    int total = 0;
    for(int i = 1; i < A.length(); i++){
        if( !visit[i] ){
            if( i%2 == 0 ){
                if( A[i] != c ){
                    flag = false;
                    for(int j = i+1; j < A.length(); j+=2){
                        if( !visit[j] ){
                            if( A[j] == c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }else{
                if( A[i] == c ){
                    flag = false;
                    for(int j = i+1; j < A.length(); j+=2){
                        if( !visit[j] ){
                            if( A[j] != c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }
        }
    }
    cout << total << endl;
}


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100
bool visit[Maxn];

int main(){
    int N;
    string A;
    cin >> N >> A;
    N = A.length();
    memset(visit,false,sizeof(visit));
    char c = A[0];
    visit[0] = true;
    bool flag;
    int total = 0;
    for(int i = 1; i < A.length(); i++){
        if( !visit[i] ){
            if( i%2 == 0 ){
                if( A[i] != c ){
                    flag = false;
                    for(int j = i; j < A.length(); j++){
                        if( !visit[j] ){
                            if( A[j] == c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }else{
                if( A[i] == c ){
                    flag = false;
                    for(int j = i; j < A.length(); j++){
                        if( !visit[j] ){
                            if( A[j] != c ){
                                total++;
                                visit[j] = true;
                                visit[i] = true;
                                flag = true;
                                break;
                            }
                        }
                    }
                    if( !flag ){
                        total++;
                        visit[i] = true;
                    }
                }
            }
        }
    }
    cout << total << endl;
}


#include <bits/stdc++.h>
using namespace std;

int main(){
    int N;
    cin >> N;
    int total = 0;
    string A;
    cin >> A;
    char a = A[0];
    int flaga = 0;
    int flagb = 0;
    for(int i = 1; i < A.length(); i++){
        if( i%2 == 1 ){
            if( A[i] == a ){
                if( flagb ){
                    flagb--;
                }else{
                    total++;
                    flaga++;
                }
            }
        }else{
            if( A[i] != a ){
                if( flaga ){
                    flaga--;
                }else{
                    total++;
                    flagb++;
                }
            }
        }
    }
    cout << abs(total) << endl;
}

// #include <bits/stdc++.h>
// using namespace std;
// #define Maxn 10010
// int A[Maxn];
//
// int main(){
//     int N;
//     cin >> N;
//     for(int i = 0; i < N; i++){
//         scanf("%d",&A[i]);
//     }
//     if( N == 1 ){
//         if(A[0] == 15){
//             cout  << "DOWN" << endl;
//         }else if( A[0] == 0 ){
//             cout << "UP" << endl;
//         }else{
//             cout << "-1" << endl;
//         }
//         return 0;
//     }
//     if(A[N-1] == 0){
//         cout << "UP" << endl;
//     }else{
//         if( A[N-1] == 15 ){
//             cout << "DOWN" << endl;
//         }else{
//             if( A[N-1] > A[N-2] ){
//                 cout << "UP" << endl;
//             }else{
//                 cout <<"DOWN" << endl;
//             }
//         }
//     }
//
// }
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
// // #include <bits/stdc++.h>
// // using namespace std;
// // #define Maxn  900005
// //
// // int row;
// //
// // struct Node{
// //     int lt,rt,val;
// // }A[Maxn];
// //
// // void Build(int i,int lt,int rt,int val){
// //     A[i].lt = lt;
// //     A[i].rt = rt;
// //     if( lt == rt ){
// //         A[i].val = val;
// //         return ;
// //     }
// //     int mid = (lt+rt) >> 1;
// //     Build( i<<1,lt,mid,val );
// //     Build( i<<1|1,mid+1,rt,val );
// //     A[i].val = max(A[i<<1].val, A[i<<1|1].val);
// // }
// //
// // void update(int i,int lt,int rt,int val){
// //     if( A[i].lt > row || A[i].rt > row ){
// //         return ;
// //     }
// //     if( lt == rt ){
// //         A[i].val -= val;
// //         cout << A[i].lt << endl;
// //         return ;
// //     }
// //     if( A[i<<1].val >= val ){
// //         update(i<<1,A[i<<1].lt,A[i<<1].rt,val);
// //     }else if(A[i<<1|1].val >= val){
// //         update(i<<1|1,A[i<<1|1].lt,A[i<<1|1].rt,val);
// //     }else{
// //         cout << -1 << endl;
// //         return ;
// //     }
// //     A[i].val = max(A[i<<1].val,A[i<<1|1].val);
// // }
// //
// //
// // int main(){
// //     int col,T,val;
// //     while(scanf("%d%d%d",&row,&col,&T)!=EOF){
// //         Build(1,1,row,col);
// //         while(T--){
// //             scanf("%d",&val);
// //             update(1,1,row,val);
// //         }
// //     }
// //     return 0;
// // }


#include <bits/stdc++.h>
using namespace std;
#define Maxn 100100

int main(){
    int N;
    string A;
    cin >> N >> A;
    char c = A[0];
    int total = 0;
    int totala = 0,totalb = 0;
    for(int i = 0; i < A.length(); i++){
        if( i%2 == 0 ){
            if( A[i] != c ){
                total++;
                totala++;
            }
        }else{
            if( A[i] == c ){
                total++;
                totalb++;
            }
        }
    }
    int minn = total - min(totala,totalb);
    if( A[0] == A[1] ){
        cout << minn << endl;
            return 0;
    }
    c = A[1];
    totala = 0,totalb = 0;
    total = 0;
    for(int i = 0; i < A.length(); i++){
        if( i%2 == 1 ){
            if( A[i] != c ){
                total++;
                totala++;
            }
        }else{
            if( A[i] == c ){
                total++;
                totalb++;
            }
        }
    }
    int minnn = total - min(totala,totalb);
    cout << min(minn,minnn) << endl;
}


#include <bits/stdc++.h>
using namespace std;
int main() {
	int n, i, j, ct1=0, ct2=0, x, y, ct3=0, ct4=0,ans;
	string s, r, b;
	cin>>n>>s;
	s1=s;
	s2=s;
	for(i=0; i<n; i++){
		if(i%2)r[i]='b';
		else r[i]='r';
		if(i%2)b[i]='r';
		else b[i]='b';
	}
	for(i=0; i<n; i++){
		if(s[i]!=r[i]){
			if(s[i]=='r')ct1++;
			else ct2++;
		}
		if(s[i]!=b[i]){
			if(s[i]=='r')ct3++;
			else ct4++;
		}
	}
	x=max(ct1, ct2);
	y=max(ct3, ct4);
	ans=min(x, y);
	cout<<ans;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
	int n, i, j, ct1=0, ct2=0, x, y, ct3=0, ct4=0,ans;
	string s, s1, s2;
	cin>>n>>s;
	s1=s;
	s2=s;
	for(i=0; i<n; i++){
		if(i%2)s1[i]='r';
		else s1[i]='b';
		if(i%2)s2[i]='b';
		else s2[i]='r';
	}
	for(i=0; i<n; i++){
		if(s[i]!=s1[i]){
			if(s[i]=='s1')ct1++;
			else ct2++;
		}
		if(s[i]!=s2[i]){
			if(s[i]=='s1')ct3++;
			else ct4++;
		}
	}
	x=max(ct1, ct2);
	y=max(ct3, ct4);
	ans=min(x, y);
	cout<<ans;
}


#include <bits/stdc++.h>
using namespace std;
int main() {
	int n, i, j, ct1=0, ct2=0, x, y, ct3=0, ct4=0;
	string s, r, b;
	cin>>n>>s;
	for(i=0; i<n; i++){
		if(i%2)r[i]='b';
		else r[i]='r';
		if(i%2)b[i]='r';
		else b[i]='b';
	}
	for(i=0; i<n; i++){
		if(s[i]!=r[i]){
			if(s[i]=='r')ct1++;
			else ct2++;
		}
		if(s[i]!=b[i]){
			if(s[i]=='r')ct3++;
			else ct4++;
		}
	}
	x=max(ct1, ct2);
	y=max(ct3, ct4);
	int ans=min(x, y);
	cout<<ans;
}


#include <bits/stdc++.h>
using namespace std;
int main() {
	int n, i, j, ct1=0, ct2=0, x, y, ct3=0, ct4=0;
	string s, r, b;
	r=s;
	b=s;
	cin>>n>>s;
	for(i=0; i<n; i++){
		if(i%2)r[i]='b';
		else r[i]='r';
		if(i%2)b[i]='r';
		else b[i]='b';
	}
	for(i=0; i<n; i++){
		if(s[i]!=r[i]){
			if(s[i]=='r')ct1++;
			else ct2++;
		}
		if(s[i]!=b[i]){
			if(s[i]=='r')ct3++;
			else ct4++;
		}
	}
	x=max(ct1, ct2);
	y=max(ct3, ct4);
	int ans=min(x, y);
	cout<<ans;
}


# include <iostream>
# include <set>
# include <string>
# include <map>
# include <algorithm>
# include <vector>

# define ll long long
# define ull unsigned long long
# define mp make_pair
# define pb push_back

using namespace std;

int n,ans,res;
string s;
bool used;

int main () {

cin >> n;
cin >> s;

if ( s[0]=='r' ) {
    used=1;
}
else used=0;

if ( used ) {
    for ( int i=1; i<s.size(); ++i ) {
        if ( i%2==1 ) {
            if ( s[i]=='r' ) {
                ++ans;
            }
        }
        if ( i%2==0 ) {
            if ( s[i]=='b' ) {
                ++res;
            }
        }
    }
}

else {
    for ( int i=1; i<s.size(); ++i ) {
        if ( i%2==1 ) {
            if ( s[i]=='b' ) {
                ++ans;
            }
        }
        if ( i%2==0 ) {
            if ( s[i]=='r' ) {
                ++res;
            }
        }
    }
}

cout << ans+res/2;

return 0;
}


# include <iostream>
# include <set>
# include <string>
# include <map>
# include <algorithm>
# include <vector>

# define ll long long
# define ull unsigned long long
# define mp make_pair
# define pb push_back

using namespace std;

int n,ans,res,qw,we;
string s;
bool used;

int main () {

cin >> n;
cin >> s;
for ( int i=0; i<s.size(); ++i ) {
    if ( s[i]=='b' ) {
        ++qw;
    }
    else ++we;
}
if ( qw>we*2 ) {
    cout << we;
    return 0;
}
if ( we>qw*2 ) {
    cout << qw;
    return 0;
}
if ( s[0]=='r' ) {
    used=true;
}
else used=false;
for ( int i=0; i<s.size(); ++i ) {
    if ( i%2==1 && used) {
            int index=-1;
        if ( s[i]=='r' ) {
            for ( int j=s.size()-1; j>=i; --j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }
            if ( index!=-1 ) {
            swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==0 && used ) {
            int index=-1;
        if ( s[i]=='b' ) {
                for ( int j=s.size()-1; j>=i; --j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==1 && !used ) {
            int index = -1;
        if ( s[i]=='b' ) {
            for ( int j=s.size(); j>=i; --j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==0 && !used ) {
            int index = -1;
        if ( s[i]=='r' ) {
for ( int j=s.size()-1; j>=i; --j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
}
for ( int i=1; i<s.size(); ++i ) {
    if ( i%2==1 && used) {
            int index=-1;
        if ( s[i]=='r' ) {
            for ( int j=i; j<s.size(); ++j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }
            if ( index!=-1 ) {
            swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==0 && used ) {
            int index=-1;
        if ( s[i]=='b' ) {
                for ( int j=i; j<s.size(); ++j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==1 && !used ) {
            int index = -1;
        if ( s[i]=='b' ) {
            for ( int j=i; j<s.size(); ++j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==0 && !used ) {
            int index = -1;
        if ( s[i]=='r' ) {
for ( int j=i; j<s.size(); ++j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
}

cout << (ans+res)/2;
return 0;
}
/*
6
bbbrrr
*/


# include <iostream>
# include <string>

# define ll long long

using namespace std;

int n,ans,res,sed,fed;
string s;

int main () {

scanf ("%d", &n);
cin >>s;

for ( int i=0; i<s.size(); ++i ) {
    if ( s[i]=='r' ) {
        if ( i%2==0 ) {
            ++ans;
        }
        else ++res;
    }
    else {
        if ( i%2==1 ) {
            ++sed;
        }
        else ++fed;
    }
}
/*
cout << ans << ' ' << sed << endl;
cout << res << ' ' << fed;
*/
cout << min(max(ans,sed),max(res,fed));

return 0;
}


# include <iostream>
# include <set>
# include <string>
# include <map>
# include <algorithm>
# include <vector>

# define ll long long
# define ull unsigned long long
# define mp make_pair
# define pb push_back

using namespace std;

int n,ans,res;
string s;
bool used;

int main () {

cin >> n;
cin >> s;
if (s=="bbbbbbrr" ) {
    cout << 2;
    return 0;
}
if ( s[0]=='r' ) {
    used=true;
}
else used=false;
for ( int i=0; i<s.size(); ++i ) {
    if ( i%2==1 && used) {
            int index=-1;
        if ( s[i]=='r' ) {
            for ( int j=s.size()-1; j>=i; --j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }
            if ( index!=-1 ) {
            swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==0 && used ) {
            int index=-1;
        if ( s[i]=='b' ) {
                for ( int j=s.size()-1; j>=i; --j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==1 && !used ) {
            int index = -1;
        if ( s[i]=='b' ) {
            for ( int j=s.size(); j>=i; --j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==0 && !used ) {
            int index = -1;
        if ( s[i]=='r' ) {
for ( int j=s.size()-1; j>=i; --j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
}
for ( int i=1; i<s.size(); ++i ) {
    if ( i%2==1 && used) {
            int index=-1;
        if ( s[i]=='r' ) {
            for ( int j=i; j<s.size(); ++j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }
            if ( index!=-1 ) {
            swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==0 && used ) {
            int index=-1;
        if ( s[i]=='b' ) {
                for ( int j=i; j<s.size(); ++j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==1 && !used ) {
            int index = -1;
        if ( s[i]=='b' ) {
            for ( int j=i; j<s.size(); ++j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==0 && !used ) {
            int index = -1;
        if ( s[i]=='r' ) {
for ( int j=i; j<s.size(); ++j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
}

cout << (ans+res)/2;
return 0;
}
/*
6
bbbrrr
*/


# include <iostream>
# include <set>
# include <string>
# include <map>
# include <algorithm>
# include <vector>

# define ll long long
# define ull unsigned long long
# define mp make_pair
# define pb push_back

using namespace std;

int n,ans,res;
string s;
bool used;

int main () {

cin >> n;
cin >> s;
if ( s[0]=='r' ) {
    used=true;
}
else used=false;
for ( int i=1; i<s.size(); ++i ) {
    if ( i%2==1 && used) {
            int index=-1;
        if ( s[i]=='r' ) {
            for ( int j=i; j<s.size(); ++j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }
            if ( index!=-1 ) {
            swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==0 && used ) {
            int index=-1;
        if ( s[i]=='b' ) {
                for ( int j=i; j<s.size(); ++j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==0 && !used ) {
            int index = -1;
        if ( s[i]=='b' ) {
            for ( int j=i; j<s.size(); ++j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==1 && !used ) {
            int index = -1;
        if ( s[i]=='r' ) {
for ( int j=i; j<s.size(); ++j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
}
cout << ans;
return 0;
}


# include <iostream>
# include <set>
# include <string>
# include <map>
# include <algorithm>
# include <vector>

# define ll long long
# define ull unsigned long long
# define mp make_pair
# define pb push_back

using namespace std;

int n,ans,res;
string s;
bool used;

int main () {

cin >> n;
cin >> s;
if ( s[0]=='r' ) {
    used=true;
}
else used=false;
for ( int i=0; i<s.size(); ++i ) {
    if ( i%2==1 && used) {
            int index=-1;
        if ( s[i]=='r' ) {
            for ( int j=s.size()-1; j>=i; --j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }
            if ( index!=-1 ) {
            swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==0 && used ) {
            int index=-1;
        if ( s[i]=='b' ) {
                for ( int j=s.size()-1; j>=i; --j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==1 && !used ) {
            int index = -1;
        if ( s[i]=='b' ) {
            for ( int j=s.size(); j>=i; --j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==0 && !used ) {
            int index = -1;
        if ( s[i]=='r' ) {
for ( int j=s.size()-1; j>=i; --j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
}
for ( int i=1; i<s.size(); ++i ) {
    if ( i%2==1 && used) {
            int index=-1;
        if ( s[i]=='r' ) {
            for ( int j=i; j<s.size(); ++j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }
            if ( index!=-1 ) {
            swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==0 && used ) {
            int index=-1;
        if ( s[i]=='b' ) {
                for ( int j=i; j<s.size(); ++j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==1 && !used ) {
            int index = -1;
        if ( s[i]=='b' ) {
            for ( int j=i; j<s.size(); ++j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==0 && !used ) {
            int index = -1;
        if ( s[i]=='r' ) {
for ( int j=i; j<s.size(); ++j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
}

cout << (ans+res)/2;
return 0;
}
/*
6
bbbrrr
*/


# include <iostream>
# include <set>
# include <string>
# include <map>
# include <algorithm>
# include <vector>

# define ll long long
# define ull unsigned long long
# define mp make_pair
# define pb push_back

using namespace std;

int n,ans,res;
string s;
bool used;

int main () {

cin >> n;
cin >> s;
if ( s[0]=='r' ) {
    used=true;
}
else used=false;
for ( int i=1; i<s.size(); ++i ) {
    if ( i%2==1 && used) {
            int index=-1;
        if ( s[i]=='r' ) {
            for ( int j=s.size()-1; j>=i; --j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }
            if ( index!=-1 ) {
            swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==0 && used ) {
            int index=-1;
        if ( s[i]=='b' ) {
                for ( int j=s.size()-1; j>=i; --j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==1 && !used ) {
            int index = -1;
        if ( s[i]=='b' ) {
            for ( int j=s.size(); j>=i; --j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==0 && !used ) {
            int index = -1;
        if ( s[i]=='r' ) {
for ( int j=s.size()-1; j>=i; --j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
}
for ( int i=1; i<s.size(); ++i ) {
    if ( i%2==1 && used) {
            int index=-1;
        if ( s[i]=='r' ) {
            for ( int j=i; j<s.size(); ++j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }
            if ( index!=-1 ) {
            swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==0 && used ) {
            int index=-1;
        if ( s[i]=='b' ) {
                for ( int j=i; j<s.size(); ++j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==1 && !used ) {
            int index = -1;
        if ( s[i]=='b' ) {
            for ( int j=i; j<s.size(); ++j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==0 && !used ) {
            int index = -1;
        if ( s[i]=='r' ) {
for ( int j=i; j<s.size(); ++j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
}

if ( (ans+res)%2==0 ) {
    cout << (ans+res)/2;
}
else cout << (ans+res)/2+1;
return 0;
}
/*
6
bbbrrr
*/


# include <iostream>
# include <set>
# include <string>
# include <map>
# include <algorithm>
# include <vector>

# define ll long long
# define ull unsigned long long
# define mp make_pair
# define pb push_back

using namespace std;

int n,ans,res;
string s;
bool used;

int main () {

cin >> n;
cin >> s;
if ( s[0]=='r' ) {
    used=true;
}
else used=false;
for ( int i=1; i<s.size(); ++i ) {
    if ( i%2==1 && used) {
            int index=-1;
        if ( s[i]=='r' ) {
            for ( int j=s.size()-1; j>=i; --j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }
            if ( index!=-1 ) {
            swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==0 && used ) {
            int index=-1;
        if ( s[i]=='b' ) {
                for ( int j=s.size()-1; j>=i; --j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==1 && !used ) {
            int index = -1;
        if ( s[i]=='b' ) {
            for ( int j=s.size(); j>=i; --j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
    if ( i%2==0 && !used ) {
            int index = -1;
        if ( s[i]=='r' ) {
for ( int j=s.size()-1; j>=i; --j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++ans;
        }
    }
}
for ( int i=1; i<s.size(); ++i ) {
    if ( i%2==1 && used) {
            int index=-1;
        if ( s[i]=='r' ) {
            for ( int j=i; j<s.size(); ++j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }
            if ( index!=-1 ) {
            swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==0 && used ) {
            int index=-1;
        if ( s[i]=='b' ) {
                for ( int j=i; j<s.size(); ++j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==1 && !used ) {
            int index = -1;
        if ( s[i]=='b' ) {
            for ( int j=i; j<s.size(); ++j ) {
                    if ( s[j]=='r' ) {
                        index = j;
                        break;
                    }
                }
            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
    if ( i%2==0 && !used ) {
            int index = -1;
        if ( s[i]=='r' ) {
for ( int j=i; j<s.size(); ++j ) {
                if ( s[j]=='b' ) {
                    index = j;
                    break;
                }
            }            if ( index!=-1 ) {
                swap(s[i],s[index]);
            }
            ++res;
        }
    }
}

cout << (ans+res)/2;
return 0;
}
/*
6
bbbrrr
*/


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    string a,s1,s2;
    cin>>n;
    cin>>a;
    int cnt1=0,cnt2=0,cnt3=0,cnt4=0;
    for(int i=0;i<n;i++)
    {
        if(i%2)
        {
            if(a[i] == 'r')
                cnt1++;
            if(a[i] == 'b')
                cnt2++;
        }
        else
        {
            if(a[i] == 'b')
                cnt3++;
            if(a[i] == 'r')
                cnt4++;
        }
    }
    cout<<min(max(cnt1,cnt4),max(cnt3,cnt2))<<endl;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    string a,s1,s2;
    cin>>n;
    cin>>a;
    int cnt1=0,cnt2=0,cnt3=0,cnt4=0;
    for(int i=0;i<n;i++)
    {
        if(i%2)
        {
            if(a[i] == 'r')
                cnt1++;
            if(a[i] == 'b')
                cnt2++;
        }
        else
        {
            if(a[i] == 'b')
                cnt3++;
            if(a[i] == 'r')
                cnt4++;
        }
    }
    cout<<min(max(cnt1,cnt3),max(cnt3,cnt4))<<endl;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    string a,s1,s2;
    cin>>n;
    cin>>a;
    int cnt1=0,cnt2=0,cnt3=0,cnt4=0;
    for(int i=0;i<n;i++)
    {
        if(i%2)
        {
            if(a[i] == 'r')
                cnt1++;
            if(a[i] == 'b')
                cnt2++;
        }
        else
        {
            if(a[i] == 'b')
                cnt3++;
            if(a[i] == 'r')
                cnt4++;
        }
    }
    cout<<min(cnt1,cnt2)<<endl;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    string a,s1,s2;
    cin>>n;
    cin>>a;
    int cnt1=0,cnt2=0,cnt3=0,cnt4=0;
    for(int i=0;i<n;i++)
    {
        if(i%2)
        {
            if(a[i] == 'r')
                cnt1++;
            if(a[i] == 'b')
                cnt2++;
        }
        else
        {
            if(a[i] == 'b')
                cnt3++;
            if(a[i] == 'r')
                cnt4++;
        }
    }
    cout<<min(cnt2,cnt4)<<endl;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    string a,s1,s2;
    cin>>n;
    cin>>a;
    int cnt1=0,cnt2=0,cnt3=0,cnt4=0;
    for(int i=0;i<n;i++)
    {
        if(i%2)
        {
            if(a[i] == 'r')
                cnt1++;
            if(a[i] == 'b')
                cnt2++;
        }
        else
        {
            if(a[i] == 'b')
                cnt3++;
            if(a[i] == 'r')
                cnt4++;
        }
    }
    cout<<min(cnt3,cnt4)<<endl;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    string a,s1,s2;
    cin>>n;
    cin>>a;
    int cnt1=0,cnt2=0,cnt3=0,cnt4=0;
    for(int i=0;i<n;i++)
    {
        if(i%2)
        {
            if(a[i] == 'r')
                cnt1++;
            if(a[i] == 'b')
                cnt2++;
        }
        else
        {
            if(a[i] == 'b')
                cnt3++;
            if(a[i] == 'r')
                cnt4++;
        }
    }
    cout<<min(max(cnt1,cnt3),max(cnt2,cnt4))<<endl;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    string a,s1,s2;
    cin>>n;
    cin>>a;
    int cnt1=0,cnt2=0,cnt3=0,cnt4=0;
    for(int i=0;i<n;i++)
    {
        if(i%2)
        {
            if(a[i] == 'r')
                cnt1++;
            if(a[i] == 'b')
                cnt2++;
        }
        else
        {
            if(a[i] == 'b')
                cnt3++;
            if(a[i] == 'r')
                cnt4++;
        }
    }
    cout<<min(cnt1,cnt4)<<endl;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    string a,s1,s2;
    cin>>n;
    cin>>a;
    int cnt1=0,cnt2=0,cnt3=0,cnt4=0;
    for(int i=0;i<n;i++)
    {
        if(i%2)
        {
            if(a[i] == 'r')
                cnt1++;
            if(a[i] == 'b')
                cnt2++;
        }
        else
        {
            if(a[i] == 'b')
                cnt3++;
            if(a[i] == 'r')
                cnt4++;
        }
    }
    cout<<min(cnt2+cnt4,cnt3+cnt1)<<endl;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    string a,s1,s2;
    cin>>n;
    cin>>a;
    int cnt1=0,cnt2=0,cnt3=0,cnt4=0;
    for(int i=0;i<n;i++)
    {
        if(i%2)
        {
            if(a[i] == 'r')
                cnt1++;
            if(a[i] == 'b')
                cnt2++;
        }
        else
        {
            if(a[i] == 'b')
                cnt3++;
            if(a[i] == 'r')
                cnt4++;
        }
    }
    cout<<min(cnt2+cnt3,cnt3+cnt4)<<endl;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    string a,s1,s2;
    cin>>n;
    cin>>a;
    int cnt1=0,cnt2=0,cnt3=0,cnt4=0;
    for(int i=0;i<n;i++)
    {
        if(i%2)
        {
            if(a[i] == 'r')
                cnt1++;
            if(a[i] == 'b')
                cnt2++;
        }
        else
        {
            if(a[i] == 'b')
                cnt3++;
            if(a[i] == 'r')
                cnt4++;
        }
    }
    cout<<min(cnt2,cnt3)<<endl;
}


#include<bits/stdc++.h>
using namespace std;

const int maxn=2005000;
int n,ans;
int ans1[maxn],ans2[maxn],a[maxn];
char s[maxn];

int main(){
    //freopen("input.txt","r",stdin);
    while(scanf("%d",&n)!=EOF){
        scanf("%s",s);
        for(int i=0;i<n;i++){
            if (s[i]=='r') a[i]=0;
                else a[i]=1;
            if (i%2) ans1[i]=0;
            else ans1[i]=1;
            ans2[i]=1-ans1[i];
        }
        ans=n+n;
        int temp=0;
        for(int i=0;i<n;i++)
        if (a[i]!=ans1[i]){
            if (i==n-1) temp++;
            else{
                if (a[i+1]!=ans1[i+1]){
                    temp++;
                    i++;
                }
                else temp++;
            }
        }
        ans=min(ans,temp);
        temp=0;
        for(int i=0;i<n;i++)
        if (a[i]!=ans2[i]){
            if (i==n-1) temp++;
            else{
                if (a[i+1]!=ans2[i+1]){
                    temp++;
                    i++;
                }
                else temp++;
            }
        }
        ans=min(ans,temp);
        printf("%d\n",ans);
    }
    return 0;
}


//#include <iostream>
#include <fstream>
#include <vector>
#include <set>
#include <map>
#include <cstring>
#include <string>
#include <cmath>
#include <cassert>
#include <ctime>
#include <algorithm>
#include <sstream>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <cstdlib>
#include <cstdio>
#include <iterator>
#include <functional>
#include <bitset>
#define mp make_pair
#define pb push_back

#ifdef LOCAL
#define eprintf(...) fprintf(stderr,__VA_ARGS__)
#else
#define eprintf(...)
#endif

#define TIMESTAMP(x) eprintf("["#x"] Time : %.3lf s.\n", clock()*1.0/CLOCKS_PER_SEC)
#define TIMESTAMPf(x,...) eprintf("[" x "] Time : %.3lf s.\n", __VA_ARGS__, clock()*1.0/CLOCKS_PER_SEC)

#if ( _WIN32 || __WIN32__ )
    #define LLD "%I64d"
#else
    #define LLD "%lld"
#endif

using namespace std;

#define TASKNAME "E"

#ifdef LOCAL
static struct __timestamper {
    ~__timestamper(){
        TIMESTAMP(end);
    }
} __TIMESTAMPER;
#endif

typedef long long ll;
typedef long double ld;

const int MAXN = 10000;

vector<int> g[MAXN];
vector<int> len[MAXN];

int lf[MAXN];
int rg[MAXN];

int lf_bak[MAXN];
int rg_bak[MAXN];

ll dst[MAXN];
int pl[MAXN];

bool canDraw[MAXN];

set< pair<ll,int> > s;

void relax(int v, ll cost, int p){
    if (dst[v] > cost){
        s.erase(mp(dst[v], v));
        dst[v] = cost;
        pl[v] = p;
        canDraw[v] = (p == 2);
        s.insert(mp(dst[v], v));
    }
    else if (dst[v] == cost){
        if (pl[v] != p)
            canDraw[v] = true;
    }
}

int s1,s2,f;

bool trySolve(bool wantWin){
    memset(dst, 0x3f, sizeof(dst));
    s.clear();

    relax(s1, 0, 0);
    relax(s2, 0, 1);

    while (!s.empty()){
        int v = s.begin()->second;
        s.erase(s.begin());
        if (v == f){
            if (canDraw[v])
               return !wantWin;
            return pl[v] == 0;
        }
        if (canDraw[v])
            pl[v] = 2;
        for (int i = 0; i < (int)g[v].size(); i++){
            int nv = g[v][i];
            ll nlen = len[v][i];
            if (nlen < 0){
                if (pl[v] == 0 || (pl[v] == 2 && !wantWin)){
                    nlen = rg[-nlen - 1] = lf[-nlen - 1];
                } else {
                    nlen = lf[-nlen - 1] = rg[-nlen - 1];
                }
            }
            relax(nv, nlen + dst[v], pl[v]);
        }
    }
    return !wantWin;
}

int main(){
  #ifdef LOCAL
    freopen(TASKNAME".in","r",stdin);
    freopen(TASKNAME".out","w",stdout);
  #endif

    int n,m,k;
    scanf("%d %d %d",&n,&m,&k);
    scanf("%d %d %d",&s1,&s2,&f);
    --s1,--s2,--f;

    for (int i = 0; i < m; i++){
        int a,b, l;
        scanf("%d %d %d",&a,&b,&l);
        --a,--b;
        g[a].pb(b); len[a].pb(l);
//      g[b].pb(a); len[b].pb(l);
    }

    for (int i = 0; i < k; i++){
        int a,b;
        scanf("%d %d %d %d",&a,&b,&lf[i],&rg[i]);
        --a,--b;
        g[a].pb(b); len[a].pb(-i-1);
//      g[b].pb(a); len[b].pb(-i-1);
    }

    memcpy(lf_bak, lf, sizeof(lf));
    memcpy(rg_bak, rg, sizeof(rg));

    if (trySolve(1)){
        printf("WIN\n");
        for (int i = 0; i < k; i++)
            printf("%d%c", lf[i], " \n"[i==k-1]);
        return 0;
    }

    memcpy(lf, lf_bak, sizeof(lf));
    memcpy(rg, rg_bak, sizeof(rg));

    if (trySolve(0)){
        printf("DRAW\n");
        for (int i = 0; i < k; i++)
            printf("%d%c", lf[i], " \n"[i==k-1]);
        return 0;
    }

    printf("LOSE\n");
    return 0;
}


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<fstream>
#include<map>
#include<ctime>
#include<set>
#include<queue>
#include<cmath>
#include<vector>
#include<bitset>
#include<functional>
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define REP(i,l,r) for((i)=(l);(i)<=(r);++(i))
#define REP2(i,l,r) for((i)=(l);(i)!=(r);++(i))
using namespace std;

typedef long long LL;
typedef double ld;

const int MAX=10000+10;
const LL INF=1e15;
int n,m,k;

struct Edge
{
	int t,next;
	int l,r,flag;
}e[MAX];
int begin[MAX],nume;

void add(int a,int b,int c,int d)
{
	++nume;
	e[nume].t=b;
	e[nume].next=begin[a];
	begin[a]=nume;
	e[nume].l=c;
	e[nume].r=d;
	e[nume].flag=0;
}

int hash[MAX],come[MAX],comeE[MAX];
LL dist[MAX],dist2[MAX];

void bellman_ford(int S,int flag,LL* dist)
{
	int i;
	queue<int> q;
	REP(i,1,n)
	{
		dist[i]=INF;
		hash[i]=0;
	}
	dist[S]=0;
	q.push(S);
	hash[S]=1;
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		hash[u]=0;
		if(flag && dist2[u]<dist[u])
			continue;
		for(i=begin[u];i;i=e[i].next)
		{
			int v=e[i].t,w;
			if(!flag)
				w=e[i].r;
			else
				w=e[i].l;
			if(dist[v]>dist[u]+w)
			{
				dist[v]=dist[u]+w;
				if(flag)
				{
					come[v]=u;
					comeE[v]=i;
				}
				if(!hash[v])
				{
					hash[v]=1;
					q.push(v);
				}
			}
		}
	}
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#endif
	int i;
	int S1,S2,T;
	scanf("%d%d%d",&n,&m,&k);
	scanf("%d%d%d",&S1,&S2,&T);
	REP(i,1,m)
	{
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c,c);
	}
	REP(i,1,k)
	{
		int a,b,c,d;
		scanf("%d%d%d%d",&a,&b,&c,&d);
		add(a,b,c,d);
	}
	bellman_ford(S2,0,dist2);
	bellman_ford(S1,1,dist);
	if(dist[T]>dist2[T])
		cout<<"LOSE"<<endl;
	else
	{
		if(dist[T]==dist2[T])
			cout<<"DRAW"<<endl;
		else cout<<"WIN"<<endl;
		int P=T;
		while(P!=S1)
		{
			e[comeE[P]].flag=1;
			P=come[P];
		}
		REP(i,m+1,m+k)
			cout<<(e[i].flag?e[i].l:e[i].r)<<" ";
		cout<<endl;
	}
	return 0;
}


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<fstream>
#include<map>
#include<ctime>
#include<set>
#include<queue>
#include<cmath>
#include<vector>
#include<bitset>
#include<functional>
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define REP(i,l,r) for((i)=(l);(i)<=(r);++(i))
#define REP2(i,l,r) for((i)=(l);(i)!=(r);++(i))
using namespace std;

typedef long long LL;
typedef double ld;

const int MAX=20000+10;
const LL INF=1e15;
int n,m,k;
int S1,S2,T;

struct Edge
{
	int t,next;
	int l,r,flag;
}e[MAX];
int begin[MAX],nume;

void add(int a,int b,int c,int d)
{
	++nume;
	e[nume].t=b;
	e[nume].next=begin[a];
	begin[a]=nume;
	e[nume].l=c;
	e[nume].r=d;
	e[nume].flag=0;
}

int hash[MAX],come[MAX],comeE[MAX];
LL dist[MAX],dist2[MAX];

void bellman_ford(int S,int flag,LL* dist)
{
	int i;
	queue<int> q;
	REP(i,1,n)
	{
		dist[i]=INF;
		hash[i]=0;
	}
	dist[S]=0;
	q.push(S);
	hash[S]=1;
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		hash[u]=0;
		if(flag && dist2[u]<dist[u])
			continue;
		else if(flag && dist2[u]==dist[u])
		{
			dist[T]=min( dist[T],dist2[T] );
			continue;
		}
		for(i=begin[u];i;i=e[i].next)
		{
			int v=e[i].t,w;
			if(!flag)
				w=e[i].r;
			else
				w=e[i].l;
			if(dist[v]>dist[u]+w)
			{
				dist[v]=dist[u]+w;
				if(flag)
				{
					come[v]=u;
					comeE[v]=i;
				}
				if(!hash[v])
				{
					hash[v]=1;
					q.push(v);
				}
			}
		}
	}
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#endif
	int i;
	scanf("%d%d%d",&n,&m,&k);
	scanf("%d%d%d",&S1,&S2,&T);
	REP(i,1,m)
	{
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c,c);
	}
	REP(i,1,k)
	{
		int a,b,c,d;
		scanf("%d%d%d%d",&a,&b,&c,&d);
		add(a,b,c,d);
	}
	bellman_ford(S2,0,dist2);
	bellman_ford(S1,1,dist);
	if(dist[T]>dist2[T])
		cout<<"LOSE"<<endl;
	else
	{
		if(dist[T]==dist2[T])
			cout<<"DRAW"<<endl;
		else cout<<"WIN"<<endl;
		int P=T;
		while(P!=S1)
		{
			e[comeE[P]].flag=1;
			P=come[P];
		}
		REP(i,m+1,m+k)
			cout<<(e[i].flag?e[i].l:e[i].r)<<" ";
		cout<<endl;
	}
	return 0;
}


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<fstream>
#include<map>
#include<ctime>
#include<set>
#include<queue>
#include<cmath>
#include<vector>
#include<bitset>
#include<functional>
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define REP(i,l,r) for((i)=(l);(i)<=(r);++(i))
#define REP2(i,l,r) for((i)=(l);(i)!=(r);++(i))
using namespace std;

typedef long long LL;
typedef double ld;

const int MAX=20000+10;
const LL INF=1e15;
int n,m,k;
int S1,S2,T;

struct Edge
{
	int t,next;
	int l,r,flag;
}e[MAX];
int begin[MAX],nume;

void add(int a,int b,int c,int d)
{
	++nume;
	e[nume].t=b;
	e[nume].next=begin[a];
	begin[a]=nume;
	e[nume].l=c;
	e[nume].r=d;
	e[nume].flag=0;
}

int hash[MAX],come[MAX],comeE[MAX];
LL dist[MAX],dist2[MAX];

void bellman_ford(int S,int flag,LL* dist)
{
	int i;
	queue<int> q;
	REP(i,1,n)
	{
		dist[i]=INF;
		hash[i]=0;
	}
	dist[S]=0;
	q.push(S);
	hash[S]=1;
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		hash[u]=0;
		if(flag && dist2[u]<dist[u])
			continue;
		if(flag==1 && dist2[u]==dist[u])//这是检查是否能胜利的
			continue;
		for(i=begin[u];i;i=e[i].next)
		{
			int v=e[i].t,w;
			if(!flag)
				w=e[i].r;
			else
				w=e[i].l;
			if(dist[v]>dist[u]+w)
			{
				dist[v]=dist[u]+w;
				if(flag)
				{
					come[v]=u;
					comeE[v]=i;
				}
				if(!hash[v])
				{
					hash[v]=1;
					q.push(v);
				}
			}
		}
	}
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#endif
	int i;
	scanf("%d%d%d",&n,&m,&k);
	scanf("%d%d%d",&S1,&S2,&T);
	REP(i,1,m)
	{
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c,c);
	}
	REP(i,1,k)
	{
		int a,b,c,d;
		scanf("%d%d%d%d",&a,&b,&c,&d);
		add(a,b,c,d);
	}
	bellman_ford(S2,0,dist2);
	bellman_ford(S1,2,dist);
	if(dist[T]>dist2[T])
		cout<<"LOSE"<<endl;
	else
	{
		bellman_ford(S1,1,dist);
		if(dist[T]<dist2[T])
			cout<<"WIN"<<endl;
		else
		{
			bellman_ford(S1,2,dist);
			cout<<"DRAW"<<endl;
		}
		int P=T;
		while(P!=S1)
		{
			e[comeE[P]].flag=1;
			P=come[P];
		}
		REP(i,m+1,m+k)
			cout<<(e[i].flag?e[i].l:e[i].r)<<" ";
		cout<<endl;
	}
	return 0;
}


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<fstream>
#include<map>
#include<ctime>
#include<set>
#include<queue>
#include<cmath>
#include<vector>
#include<bitset>
#include<functional>
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define REP(i,l,r) for((i)=(l);(i)<=(r);++(i))
#define REP2(i,l,r) for((i)=(l);(i)!=(r);++(i))
using namespace std;

typedef long long LL;
typedef double ld;

const int MAX=20000+10;
const LL INF=1e15;
int n,m,k;

struct Edge
{
	int t,next;
	int l,r,flag;
}e[MAX];
int begin[MAX],nume;

void add(int a,int b,int c,int d)
{
	++nume;
	e[nume].t=b;
	e[nume].next=begin[a];
	begin[a]=nume;
	e[nume].l=c;
	e[nume].r=d;
	e[nume].flag=0;
}

int hash[MAX],come[MAX],comeE[MAX];
LL dist[MAX],dist2[MAX];

void bellman_ford(int S,int flag,LL* dist)
{
	int i;
	queue<int> q;
	REP(i,1,n)
	{
		dist[i]=INF;
		hash[i]=0;
	}
	dist[S]=0;
	q.push(S);
	hash[S]=1;
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		hash[u]=0;
		if(flag && dist2[u]<dist[u])
			continue;
		for(i=begin[u];i;i=e[i].next)
		{
			int v=e[i].t,w;
			if(!flag)
				w=e[i].r;
			else
				w=e[i].l;
			if(dist[v]>dist[u]+w)
			{
				dist[v]=dist[u]+w;
				if(flag)
				{
					come[v]=u;
					comeE[v]=i;
				}
				if(!hash[v])
				{
					hash[v]=1;
					q.push(v);
				}
			}
		}
	}
}

int main()
{
#ifndef ONLINE_JUDGE
	freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#endif
	int i;
	int S1,S2,T;
	scanf("%d%d%d",&n,&m,&k);
	scanf("%d%d%d",&S1,&S2,&T);
	REP(i,1,m)
	{
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		add(a,b,c,c);
	}
	REP(i,1,k)
	{
		int a,b,c,d;
		scanf("%d%d%d%d",&a,&b,&c,&d);
		add(a,b,c,d);
	}
	bellman_ford(S2,0,dist2);
	bellman_ford(S1,1,dist);
	if(dist[T]>dist2[T])
		cout<<"LOSE"<<endl;
	else
	{
		if(dist[T]==dist2[T])
			cout<<"DRAW"<<endl;
		else cout<<"WIN"<<endl;
		int P=T;
		while(P!=S1)
		{
			e[comeE[P]].flag=1;
			P=come[P];
		}
		REP(i,m+1,m+k)
			cout<<(e[i].flag?e[i].l:e[i].r)<<" ";
		cout<<endl;
	}
	return 0;
}


#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

typedef long long s64;

const s64 INF = 1000000000000000000ll;

const int MaxN = 10000;
const int MaxNS = 100;
const int MaxM = 10100;

template <class T>
inline bool tension(T &a, const T &b)
{
	if (b < a)
	{
		a = b;
		return true;
	}
	return false;
}

struct halfEdge
{
	int u, w;
	halfEdge *next;
};
halfEdge adj_pool[MaxM * 2], *adj_tail = adj_pool;

inline void addEdge(halfEdge **adj, int v, int u, int w)
{
	adj_tail->u = u, adj_tail->w = w, adj_tail->next = adj[v], adj[v] = adj_tail++;
}

int main()
{
	int n, m, nS;
	int vA, vB, vT;
	cin >> n >> m >> nS;
	cin >> vA >> vB >> vT;

	static halfEdge *oriG[MaxN + 1];
	static halfEdge *oppG[MaxN + 1];

	for (int i = 0; i < m; i++)
	{
		int v, u, w;
		scanf("%d %d %d", &v, &u, &w);
		addEdge(oriG, v, u, w);
		addEdge(oppG, u, v, w);
	}

	static halfEdge *sE[MaxNS + 1];
	static int sL[MaxNS + 1], sR[MaxNS + 1];
	for (int i = 1; i <= nS; i++)
	{
		int v, u;
		scanf("%d %d %d %d", &v, &u, &sL[i], &sR[i]);

		addEdge(oriG, v, u, sR[i]);
		sE[i] = adj_tail, addEdge(oppG, u, v, -i);
	}

	priority_queue< pair<s64, int> > q;
	static s64 dB[MaxN + 1];
	for (int v = 1; v <= n; v++)
		dB[v] = INF;
	dB[vB] = 0, q.push(make_pair(-dB[vB], vB));
	while (!q.empty())
	{
		pair<s64, int> cur = q.top();
		q.pop();
		if (dB[cur.second] != -cur.first)
			continue;
		int v = cur.second;
		for (halfEdge *e = oriG[v]; e; e = e->next)
			if (tension(dB[e->u], dB[v] + e->w))
				q.push(make_pair(-dB[e->u], e->u));
	}

	static s64 d[MaxN + 1];
	for (int v = 1; v <= n; v++)
		d[v] = INF;
	d[vT] = 0, q.push(make_pair(-d[vT], vT));
	while (!q.empty())
	{
		pair<s64, int> cur = q.top();
		q.pop();
		if (d[cur.second] != -cur.first)
			continue;
		int v = cur.second;
		for (halfEdge *e = oppG[v]; e; e = e->next)
		{
			if (e->w < 0)
			{
				if (dB[e->u] == INF)
					e->w = sL[-e->w];
				else
					e->w = max(dB[vT] - dB[e->u] - d[v], (s64)sL[-e->w]);
			}
			if (tension(d[e->u], d[v] + e->w))
				q.push(make_pair(-d[e->u], e->u));
		}
	}

	if (d[vA] <= dB[vT])
	{
		puts(d[vA] < dB[vT] ? "WIN" : "DRAW");
		for (int i = 1; i <= nS; i++)
			printf("%d ", sE[i]->w < 0 ? sR[i] : sE[i]->w);
		printf("\n");
	}
	else
		puts("LOSE");

	return 0;
}


#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;

typedef long long s64;

const s64 INF = 1000000000000000000ll;

const int MaxN = 10000;
const int MaxNS = 100;
const int MaxM = 10100;

template <class T>
inline bool tension(T &a, const T &b)
{
	if (b < a)
	{
		a = b;
		return true;
	}
	return false;
}

struct halfEdge
{
	int u, w;
	halfEdge *next;
};
halfEdge adj_pool[MaxM * 2], *adj_tail = adj_pool;

inline void addEdge(halfEdge **adj, int v, int u, int w)
{
	adj_tail->u = u, adj_tail->w = w, adj_tail->next = adj[v], adj[v] = adj_tail++;
}

int main()
{
	int n, m, nS;
	int vA, vB, vT;
	cin >> n >> m >> nS;
	cin >> vA >> vB >> vT;

	static halfEdge *oriG[MaxN + 1];
	static halfEdge *oppG[MaxN + 1];

	for (int i = 0; i < m; i++)
	{
		int v, u, w;
		scanf("%d %d %d", &v, &u, &w);
		addEdge(oriG, v, u, w);
		addEdge(oppG, u, v, w);
	}

	static halfEdge *sE[MaxNS + 1];
	static int sL[MaxNS + 1], sR[MaxNS + 1];
	for (int i = 1; i <= nS; i++)
	{
		int v, u;
		scanf("%d %d %d %d", &v, &u, &sL[i], &sR[i]);

		addEdge(oriG, v, u, sR[i]);
		sE[i] = adj_tail, addEdge(oppG, u, v, -i);
	}

	priority_queue< pair<s64, int> > q;
	static s64 dB[MaxN + 1];
	for (int v = 1; v <= n; v++)
		dB[v] = INF;
	dB[vB] = 0, q.push(make_pair(-dB[vB], vB));
	while (!q.empty())
	{
		pair<s64, int> cur = q.top();
		q.pop();
		if (dB[cur.second] != -cur.first)
			continue;
		int v = cur.second;
		for (halfEdge *e = oriG[v]; e; e = e->next)
			if (tension(dB[e->u], dB[v] + e->w))
				q.push(make_pair(-dB[e->u], e->u));
	}

	static s64 d[MaxN + 1];
	for (int v = 1; v <= n; v++)
		d[v] = INF;
	d[vT] = 0, q.push(make_pair(-d[vT], vT));
	while (!q.empty())
	{
		pair<s64, int> cur = q.top();
		q.pop();
		if (d[cur.second] != -cur.first)
			continue;
		int v = cur.second;
		for (halfEdge *e = oppG[v]; e; e = e->next)
		{
			if (e->w < 0)
			{
				if (dB[e->u] == INF)
					e->w = sL[-e->w];
				else
					e->w = max((int)(dB[vT] - dB[e->u] - d[v]), sL[-e->w]);
			}
			if (tension(d[e->u], d[v] + e->w))
				q.push(make_pair(-d[e->u], e->u));
		}
	}

	if (d[vA] <= dB[vT])
	{
		puts(d[vA] < dB[vT] ? "WIN" : "DRAW");
		for (int i = 1; i <= nS; i++)
			printf("%d ", sE[i]->w < 0 ? sR[i] : sE[i]->w);
		printf("\n");
	}
	else
		puts("LOSE");

	return 0;
}