#include <bits/stdc++.h>

using namespace std;

const int N = 2e5 + 5;
vector<int> g[N];
bool vis[N];
int tVis[N];

int main() {
    //freopen("input.txt", "r", stdin);
    ios_base::sync_with_stdio(false);
    int cases;
    cin >> cases;
    while (cases--) {
        int n, m, k;
        cin >> n >> m >> k;
        for (int i = 1; i <= n; ++i) {
            g[i].clear();
            vis[i] = false;
        }
        for (int i = 1; i <= m; ++i) {
            int v, u;
            cin >> v >> u;
            g[v].push_back(u);
            g[u].push_back(v);
        }
        int x = -1;
        for (int i = 1; i <= n; ++i) {
            if (int(g[i].size()) < k) {
                x = i;
                break;
            }
        }
        if (x != -1) {
            cout << "CUT\n";
            cout << "1\n" << x;
        } else {
            vector<int> st;
            int v = 1;
            int timer = 0;
            while (!vis[v]) {
                vis[v] = true;
                st.push_back(v);
                tVis[v] = ++timer;
                int notVisU = -1, minVisU = -1;
                for (size_t j = 0; j < g[v].size(); ++j) {
                    int u = g[v][j];
                    if (!vis[u]) {
                        notVisU = u;
                        break;
                    } else {
                        if (minVisU == -1 || tVis[minVisU] > tVis[u]) {
                            minVisU = u;
                        }
                    }
                }
                if (notVisU != -1) {
                    v = notVisU;
                } else {
                    cout << "CYCLE\n";
                    vector<int> cycle;
                    while (st.back() != minVisU) {
                        cycle.push_back(st.back());
                        st.pop_back();
                    }
                    cycle.push_back(st.back());
                    cout << cycle.size() << "\n";
                    for (size_t i = 0; i < cycle.size(); ++i) {
                        cout << cycle[i] << " ";
                    }
                    break;
                }
            }
        }
        cout << "\n";
    }
    return 0;
}

#include <iostream>
#include <algorithm>
#include <assert.h>
#include <string>
#include <vector>
#include <set>
using namespace std;

long long readInt(long long l,long long r,char endd){
    long long x=0;
    int cnt=0;
    int fi=-1;
    bool is_neg=false;
    while(true){
        char g=getchar();
        if(g=='-'){
            assert(fi==-1);
            is_neg=true;
            continue;
        }
        if('0'<=g && g<='9'){
            x*=10;
            x+=g-'0';
            if(cnt==0){
                fi=g-'0';
            }
            cnt++;
            assert(fi!=0 || cnt==1);
            assert(fi!=0 || is_neg==false);

            assert(!(cnt>19 || ( cnt==19 && fi>1) ));
        } else if(g==endd){
            assert(cnt>0);
            if(is_neg){
                x= -x;
            }
            assert(l<=x && x<=r);
            return x;
        } else {
            assert(false);
        }
    }
}
string readString(int l,int r,char endd){
    string ret="";
    int cnt=0;
    while(true){
        char g=getchar();
        assert(g!=-1);
        if(g==endd){
            break;
        }
        cnt++;
        ret+=g;
    }
    assert(l<=cnt && cnt<=r);
    return ret;
}
long long readIntSp(long long l,long long r){
    return readInt(l,r,' ');
}
long long readIntLn(long long l,long long r){
    return readInt(l,r,'\n');
}
string readStringLn(int l,int r){
    return readString(l,r,'\n');
}
string readStringSp(int l,int r){
    return readString(l,r,' ');
}


int T;
int n,m,k;
vector<int> adj[200200];
vector<int> ind[200200];
set<pair<int,int>> gg;
int sm_n=0,sm_m=0;
int order[200200];
bool vis[200200];
int bef[200200];

void dfs(int nd){
    vis[nd]=true;
    for(int i=0;i<adj[nd].size();i++){
        int ch=adj[nd][i];
        if(vis[ch])continue;
        dfs(ch);
    }
}
int main(){
    T=readIntLn(1,100);
    while(T--){
        n=readIntSp(2,200000);
        m=readIntSp(2,200000);
        k=readIntLn(2,n);
        sm_n += n;
        sm_m += m;
        gg.clear();
        assert(sm_n<= 200000);
        assert(sm_m<= 200000);
        for(int i=1;i<=n;i++){
            order[i]=-1;
            vis[i]=false;
            adj[i].clear();
            ind[i].clear();
        }
        for(int i=1;i<=m;i++){
            int a,b;
            a=readIntSp(1,n);
            b=readIntLn(1,n);
            assert(a!=b);
            assert(gg.count(make_pair(a,b)) == 0);
            assert(gg.count(make_pair(b,a)) == 0);
            gg.insert(make_pair(a,b));
            adj[a].push_back(b);
            adj[b].push_back(a);
            ind[a].push_back(i);
            ind[b].push_back(i);
        }
        dfs(1);
        for(int i=1;i<=n;i++){
            assert(vis[i]);
        }
        int cut=-1;
        for(int i=1;i<=n;i++){
            if(adj[i].size() < k){
                cut = i;
                break;
            }
        }
        if(cut != -1){
            printf("CUT\n");
            printf("%d\n",1);
            printf("%d\n",cut);
            continue;
        }
        vector<int> cycle;
        int cur = 1;
        int c=0;
        bool found=false;
        while(true){
            order[cur]=c++;
            for(int i=0;i<adj[cur].size();i++){
                int ch=adj[cur][i];
                if(ch==bef[cur])continue;
                if(order[ch] == -1){
                    bef[ch]=cur;
                    cur=ch;
                    break;
                } else if(c- order[ch] >= k ){
                    found=true;
                    while(cur != ch){
                        cycle.push_back(cur);
                        cur=bef[cur];
                    }
                    cycle.push_back(ch);
                    break;
                }
            }
            if(found){
                break;
            }
        }
        printf("CYCLE %d\n",cycle.size());
        for(int i=0;i<cycle.size();i++){
            printf("%d ",cycle[i]);
        }
    }
    assert(getchar()==-1);
}

#include <iostream>
#include<bits/stdc++.h>

using namespace std;

int n,m,k;
vector<int> arr[300000];
bool endDFS=false;
int timer=0;//Time and timer variables are used in Euler tour of the graph. Go ahead an have a look at the concept after this!!

void DFS(int u,int v,int time[],stack<int> &st)//Stack passed by reference. "&" operator represents passing
//memory address instead of copying the entire value.
{
    if(time[u]>0 or endDFS==true)
        return; //Already visited.
    time[u]=timer++;
    st.push(u);
    bool noNodeVisited=true;
    int earliestVisitedNode=10000,minTime=10000000;
    for(auto i:arr[u])
    {
        if(i!=v and time[i]==0)//Simple DFS
        {
            noNodeVisited=false;
            DFS(i,u,time,st);
        } else if(time[i]<minTime)//Earliest visited vertex calculation goes on simultaneously. (So we dont have to do it
        //inside the if(noNodeVisited==true) condition. Lazy me :3
        {
            minTime=time[i];
            earliestVisitedNode=i;
        }
    }
    if(noNodeVisited==true)
    {
        endDFS=true;
        vector<int> cycle;//Store cycle in an array
        while(st.top()!=earliestVisitedNode)
        {
            cycle.push_back(st.top());
            st.pop();
        }
        cycle.push_back(earliestVisitedNode);
        assert(earliestVisitedNode==st.top());
        cout<<"CYCLE\n"<<cycle.size()<<"\n";
        for(auto i:cycle)
            cout<<i<<" ";
        cout<<"\n";
        return;
    }
}

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        //Input Taking
        cin>>n>>m>>k;
        int i,u,v;
        for(i=0;i<=n;i++)
        {
            arr[i].clear();
        }
        for(i=0;i<m;i++)
        {
            cin>>u>>v;
            arr[u].push_back(v);
            arr[v].push_back(u);
        }
        //Mindegree= Minimum Degree, minU = vertex U with minimum degree
        int minDegree=n,minU=-1;
        for(i=1;i<=n;i++)
        {
            if(arr[i].size()<minDegree)
            {
                minDegree=arr[i].size();
                minU=i;
            }
        }

        if(minDegree<k)
        {
            //Note that cut problem never says about size of sets A and B!! Hence, we make size of set A as 1,
            //It will contain only vertex u, found above.
            assert(minU!=-1);
            cout<<"CUT\n"<<1<<"\n"<<minU<<"\n";
        }
        else
        {
            //Each vertex has a degree >=k ==>A cycle of length atleast k (or actually, k+1) MUST exist.
            //We will do as described in editorial. DFS until we find a node whose every neighbour is visited.
            //Close the cycle by placing edge between that node and the node visited earliest for largest cycle length.
            //Setter's solution used iterative DFS for that, I will do recursive as its intuitive.
            int time[200100]={0};
            timer=0;
            endDFS=false;
            stack< int > st;
            DFS(1,0,time,st);
        }

    }
    return 0;
}

Refer to the example I gave there on lines of last node. Each node has a degree of $K$ , and they are all finite. At the end of the day, there has to be one last node which we visit, and for that last node, all of its neighbors must be already visited, else that node isnt the last node.

Hence, we proved this by existence, saying that the last node will always fit in the description.

This is done to get cycle of largest possible length, which guarantees that this cycle will be of length at least $K$. Else, we may end up with a smaller cycle. Some hand made examples will do good to you.

Let's consider vertex $v$ with minimal degree (degree is number of neighbors). If $degree(v) < k$, than we have found a good cut: we can choose $A = \{v\}$. Otherwise, for all vertices $v$ is true that $degree(v) \geq k$. Let's go from vertex $v$ in neighbor $u$, if it's not visited earlier, after that, go from $u$ to not visited vertex $w$ and so on. In some moment we will have the situation that all neighbors of some vertex $f$ is visited earlier, let's consider neighbor which we have visited earlier than another ones ($u$). It's clear that path between $u$ and $f$ through visited vertices and edge $(u, v)$ forms a correct simple cycle.

Brief Solution for NPORP:If there's one node with degree less than $K$, then we have found a cut, we can cut all edges connected to that node.

Now let's assume the degree of all nodes is at least $K$ and try to find a cycle of length $K$. Let's start at arbitrary node and continue walk to arbitrary unvisited node, each time we visit a node we write a number on it starting from $1$ for the first node and $2$ for second node we visit and so on (Editorialist's Note- He is referring to the time array I mentioned).

When we reach a node where all adjacent nodes are already visited now we choose the node having the least number on it (Editorialist's Note- i.e. earliest visited node) and close the cycle there. Since we know the degree of the current node is at least $K$ and all numbers on all nodes are distinct we know our cycle will have length at least $K$.

Currently Empty. There were no test cases which proved tricky or edgy. The implementation also had very little scope of error. If, however, you got WA and cant find the failing case, feel free to comment on the editorial with link to your solution. I request the community to help in maintaining it by editing and adding the test cases themselves in case I miss updating the editorial.

1. Not interrelating the problems leading to a difficult and wrong implementation/idea. Eg- Trying to solve CYCLE problem first without condition of "Degree of all nodes is $\ge K$"
2. Not resetting global variables and not clearing the graph after each test case.

Aside from that, most solutions had unique errors in implementation. Some did not follow constraint that cycle must be of length at least $K$ and printed any cycle. There were many avoidable errors committed, perhaps due to panic as the problem seemed tough. Lets try to avoid that hence forth :)

Full Solution - The one I gave earlier.
StackOverflow Answer - Uses the path argument. Similar to my last node argument/case.