[CF]Codeforces Round #575 (Div. 3)

D2. RGB Substring (hard version)

Description

The only difference between easy and hard versions is the size of the input.

You are given a string ss consisting of nn characters, each character is 'R', 'G' or 'B'.

You are also given an integer kk. Your task is to change the minimum number of characters in the initial string ss so that after the changes there will be a string of length kk that is a substring of ss, and is also a substring of the infinite string "RGBRGBRGB ...".

A string aa is a substring of string bb if there exists a positive integer ii such that a1=bia1=bi, a2=bi+1a2=bi+1, a3=bi+2a3=bi+2, ..., a|a|=bi+|a|−1a|a|=bi+|a|−1. For example, strings "GBRG", "B", "BR" are substrings of the infinite string "RGBRGBRGB ..." while "GR", "RGR" and "GGG" are not.

You have to answer qq independent queries.

Input

The first line of the input contains one integer qq (1≤q≤2⋅1051≤q≤2⋅105) — the number of queries. Then qq queries follow.

The first line of the query contains two integers nn and kk (1≤k≤n≤2⋅1051≤k≤n≤2⋅105) — the length of the string ss and the length of the substring.

The second line of the query contains a string ss consisting of nn characters 'R', 'G' and 'B'.

It is guaranteed that the sum of nn over all queries does not exceed 2⋅1052⋅105 (∑n≤2⋅105∑n≤2⋅105).

output

For each query print one integer — the minimum number of characters you need to change in the initial string ss so that after changing there will be a substring of length kk in ss that is also a substring of the infinite string "RGBRGBRGB ...".

Examples

Input

3
5 2
BGGGG
5 3
RBRGR
5 5
BBBRR

Output

1
0
3

正确解法：

给你一个长度为n的字串，让你修改几个字符，使他拥有一个　　“RGBRGBR...”长度为k的连续子字符串。

我们设三个长度为n的字符串：

RGBRGB...

GBRGBR...

BRGBRG...

分别匹配他与当前字符串的匹配度。

也就是说如果某个字符相等的话，匹配度+1。

最后找 长度为k的连续子字符串匹配度的最大值。

k-这个最大值，就是 修改的最小次数。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <cctype>
#include <sstream>
using namespace std;
typedef long long ll;
const int inf=0x7fffffff;
const int N=200000+100;
const int M=5000+10;
const double PI=acos(-1.0);
int T;
int n,k;
string s;
string k1="RGB",k2="GBR",k3="BRG";
int sum[5][N];
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d %d",&n,&k);
        cin>>s;
        for(int i=0;i<=n+1;i++)
            sum[0][i]=sum[1][i]=sum[2][i]=0;
        for(int i=0;i<n;i++)
        {
            sum[0][i+1]=sum[0][i];
            sum[1][i+1]=sum[1][i];
            sum[2][i+1]=sum[2][i];
            if(s[i]==k1[i%3])   sum[0][i+1]++;
            if(s[i]==k2[i%3])   sum[1][i+1]++;
            if(s[i]==k3[i%3])   sum[2][i+1]++;
        }
        int ans=0;
        for(int i=0;i+k<=n;i++)
            for(int j=0;j<3;j++)
                ans=max(ans,sum[j][i+k]-sum[j][i]);
        printf("%d
",k-ans);
 
    }
 
    return 0;
}

F. K-th Path

Description

You are given a connected undirected weighted graph consisting of nn vertices and mm edges.

You need to print the kk-th smallest shortest path in this graph (paths from the vertex to itself are not counted, paths from ii to jj and from jj to ii are counted as one).

More formally, if dd is the matrix of shortest paths, where di,jdi,j is the length of the shortest path between vertices ii and jj (1≤i<j≤n1≤i<j≤n), then you need to print the kk-th element in the sorted array consisting of all di,jdi,j, where 1≤i<j≤n1≤i<j≤n.

Input

The first line of the input contains three integers n,mn,m and kk (2≤n≤2⋅1052≤n≤2⋅105, n−1≤m≤min(n(n−1)2,2⋅105)n−1≤m≤min(n(n−1)2,2⋅105), 1≤k≤min(n(n−1)2,400)1≤k≤min(n(n−1)2,400) — the number of vertices in the graph, the number of edges in the graph and the value of kk, correspondingly.

Then mm lines follow, each containing three integers xx, yy and ww (1≤x,y≤n1≤x,y≤n, 1≤w≤1091≤w≤109, x≠yx≠y) denoting an edge between vertices xx and yy of weight ww.

It is guaranteed that the given graph is connected (there is a path between any pair of vertices), there are no self-loops (edges connecting the vertex with itself) and multiple edges (for each pair of vertices xx and yy, there is at most one edge between this pair of vertices in the graph).

output

Print one integer — the length of the kk-th smallest shortest path in the given graph (paths from the vertex to itself are not counted, paths from ii to jj and from jj to ii are counted as one).

Examples

Input

6 10 5
2 5 1
5 3 9
6 2 2
1 3 1
5 1 8
6 5 10
1 6 5
6 4 6
3 6 2
3 4 5

Output

3

正确解法：

问你一个图中，按长度排序第k小的边的长度为多少。

这肯定不能求最短路，因为不是单点的。

因为k的范围特别小，我们可以从这里入手。

我们找k条短边组成一个新图，那么第k小的边一定在这里。

floyed一下就好了，因为k条边最最多有2*k个点。n^3 的复杂度不会超。

点那么大怎么组新图呢，离散化啊

还有一点要注意的是 m不一定大于k。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<cmath>
#include<cstdlib>
#include<stack>
#define de printf("
debug:
")
#define End printf("
end

")
#define fi first
#define se second
#define P pair< int, int >
#define PII pair< pair<int, int> ,int>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int mod=1e5+7;
const int N=2e5+100;
const int inf=0x7fffffff;
int n,m,k;
ll b[1100][1100];
struct node
{
    int x,y,v;
}e[N];
vector<ll>edge,kk;
int cmp(node a,node b)
{
    return a.v<b.v;
}
int main()
{
    scanf("%d %d %d",&n,&m,&k);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].v);
    }
    sort(e+1,e+m+1,cmp);
    for(int i=1;i<=min(m,k);i++)
    {
        edge.push_back(e[i].x);
        edge.push_back(e[i].y);
    }
    sort(edge.begin(),edge.end());
    edge.resize(unique(edge.begin(),edge.end())-edge.begin());
    int cnt=edge.size();
    for(int i=0;i<cnt;i++)
        for(int j=0;j<cnt;j++)
            b[i][j]=1e18;
    for(int i=0;i<cnt;i++)
        b[i][i]=0;
    for(int i=1;i<=min(m,k);i++)
    {
        int xx=lower_bound(edge.begin(),edge.end(),e[i].x)-edge.begin();
        int yy=lower_bound(edge.begin(),edge.end(),e[i].y)-edge.begin();
        b[xx][yy]=b[yy][xx]=e[i].v;
    }
    for(int i=0;i<cnt;i++)
        for(int j=0;j<cnt;j++)
            for(int k=0;k<cnt;k++)
                if(b[j][k]>b[j][i]+b[i][k])
                    b[j][k]=b[j][i]+b[i][k];
    for(int i=0;i<cnt;i++)
        for(int j=0;j<i;j++)
            kk.push_back(b[i][j]);
    sort(kk.begin(),kk.end());
    printf("%lld
",kk[k-1]);


    return 0;
}