Submission #861501

# Submission time Handle Problem Language Result Execution time Memory
861501 2023-10-16T11:20:11 Z Faisal_Saqib Pipes (CEOI15_pipes) C++17
30 / 100
299 ms 65536 KB
#include <iostream>
#include <algorithm>
#include <climits>
#include <cmath>
#include <map>
#include <set>
#include <bitset>
#include <iomanip>
#include <vector>

using namespace std;
static struct FastInput {
    static constexpr int BUF_SIZE = 1 << 20;
    char buf[BUF_SIZE];
    size_t chars_read = 0;
    size_t buf_pos = 0;
    FILE *in = stdin;
    char cur = 0;
    
    inline char get_char() {
        if (buf_pos >= chars_read) {
            chars_read = fread(buf, 1, BUF_SIZE, in);
            buf_pos = 0;
            buf[0] = (chars_read == 0 ? -1 : buf[0]);
        }
        return cur = buf[buf_pos++];
    }
    
    inline void tie(int) {}
    
    inline explicit operator bool() {
        return cur != -1;
    }
    
    inline static bool is_blank(char c) {
        return c <= ' ';
    }
    
    inline bool skip_blanks() {
        while (is_blank(cur) && cur != -1) {
            get_char();
        }
        return cur != -1;
    }
    
    inline FastInput& operator>>(char& c) {
        skip_blanks();
        c = cur;
        return *this;
    }
    
    inline FastInput& operator>>(string& s) {
        if (skip_blanks()) {
            s.clear();
            do {
                s += cur;
            } while (!is_blank(get_char()));
        }
        return *this;
    }
    
    template <typename T>
    inline FastInput& read_integer(T& n) {
        // unsafe, doesn't check that characters are actually digits
        n = 0;
        if (skip_blanks()) {
            int sign = +1;
            if (cur == '-') {
                sign = -1;
                get_char();
            }
            do {
                n += n + (n << 3) + cur - '0';
            } while (!is_blank(get_char()));
            n *= sign;
        }
        return *this;
    }
    
    template <typename T>
    inline typename enable_if<is_integral<T>::value, FastInput&>::type operator>>(T& n) {
        return read_integer(n);
    }
    
#if !defined(_WIN32) || defined(_WIN64)
    inline FastInput& operator>>(__int128& n) {
        return read_integer(n);
    }
#endif
    
    template <typename T>
    inline typename enable_if<is_floating_point<T>::value, FastInput&>::type operator>>(T& n) {
        // not sure if really fast, for compatibility only
        n = 0;
        if (skip_blanks()) {
            string s;
            (*this) >> s;
            sscanf(s.c_str(), "%lf", &n);
        }
        return *this;
    }
} fast_input;
 
#define cin fast_input
 
static struct FastOutput {
    static constexpr int BUF_SIZE = 1 << 20;
    char buf[BUF_SIZE];
    size_t buf_pos = 0;
    static constexpr int TMP_SIZE = 1 << 20;
    char tmp[TMP_SIZE];
    FILE *out = stdout;
    
    inline void put_char(char c) {
        buf[buf_pos++] = c;
        if (buf_pos == BUF_SIZE) {
            fwrite(buf, 1, buf_pos, out);
            buf_pos = 0;
        }
    }
    
    ~FastOutput() {
        fwrite(buf, 1, buf_pos, out);
    }
    
    inline FastOutput& operator<<(char c) {
        put_char(c);
        return *this;
    }
    
    inline FastOutput& operator<<(const char* s) {
        while (*s) {
            put_char(*s++);
        }
        return *this;
    }
    
    inline FastOutput& operator<<(const string& s) {
        for (int i = 0; i < (int) s.size(); i++) {
            put_char(s[i]);
        }
        return *this;
    }
    
    template <typename T>
    inline char* integer_to_string(T n) {
        // beware of TMP_SIZE
        char* p = tmp + TMP_SIZE - 1;
        if (n == 0) {
            *--p = '0';
        } else {
            bool is_negative = false;
            if (n < 0) {
                is_negative = true;
                n = -n;
            }
            while (n > 0) {
                *--p = (char) ('0' + n % 10);
                n /= 10;
            }
            if (is_negative) {
                *--p = '-';
            }
        }
        return p;
    }
    
    template <typename T>
    inline typename enable_if<is_integral<T>::value, char*>::type stringify(T n) {
        return integer_to_string(n);
    }
    
#if !defined(_WIN32) || defined(_WIN64)
    inline char* stringify(__int128 n) {
        return integer_to_string(n);
    }
#endif
    
    template <typename T>
    inline typename enable_if<is_floating_point<T>::value, char*>::type stringify(T n) {
        sprintf(tmp, "%.17f", n);
        return tmp;
    }
    
    template <typename T>
    inline FastOutput& operator<<(const T& n) {
        auto p = stringify(n);
        for (; *p != 0; p++) {
            put_char(*p);
        }
        return *this;
    }
} fast_output;
 
#define cout fast_output
const int MAXN=1e5+1;
const int LG=17;
int** pa;
int *par,*h,*Up,*par1;
vector<int> ma[MAXN];
int get1(int& a)
{
	return ((par1[a]==a)?a:par1[a]=get1(par1[a]));
}
void join1(int a,int b)
{
	a=get1(a);
	b=get1(b);
	if(a!=b)
		par1[a]=b;
}
int get(int& a)
{
	return ((par[a]==a)?a:par[a]=get(par[a]));
}
bool join(int a,int b)
{
	a=get(a);
	b=get(b);
	if(a!=b)
	{
		par[a]=b;
		return 1;
	}
	return 0;
}
void dfs(int& x,int& p)
{
	// cout<<x<<' '<<p<<endl;
	pa[x][0]=p;
	for(int j=1;j<LG;j++)
		pa[x][j]=pa[pa[x][j-1]][j-1];
	h[x]=h[p]+1;
	for(auto y:ma[x])
		if(y!=p)
			dfs(y,x);
}
int lca(int x,int y)
{
	if(h[x]>h[y])
		swap(x,y);
	for(int j=LG-1;j>=0;j--)
		if(h[x]<=h[pa[y][j]])
			y=pa[y][j];
	if(x==y)
		return x;
	for(int j=LG-1;j>=0;j--)
		if(pa[x][j]!=pa[y][j])
		{
			x=pa[x][j];
			y=pa[y][j];
		}
	return pa[x][0];
}
void solve(int& x,int& p)
{
	for(auto y:ma[x])
	{
		if(y!=p)
		{
			solve(y,x);
		}
	}
	for(auto y:ma[x])
	{
		if(y!=p)
		{
			if(h[Up[x]]>h[Up[y]])
			{
				Up[x]=Up[y];
			}
			if(Up[y]==y)
			{
				cout<<x<<' '<<y<<'\n';
			}
		}
	}
}
int main(){
	ios::sync_with_stdio(false);
	// cin.tie(NULL);
	// cout.tie(NULL);
    int n,m;
    cin>>n>>m;
	par=new int[n+1];
	par1=new int[n+1];
	h=new int[n+1];
	Up=new int[n+1];
	pa=new int*[n+1];
    for(int i=1;i<=n;i++)
    {
    	pa[i]=new int[LG];
    	par[i]=par1[i]=Up[i]=i;
    }
    for(int i=0;i<m;i++)
    {
    	int x,y;
    	cin>>x>>y;
    	if(join(x,y))
    	{
    		// cout<<"Tree Edge "<<x<<' '<<y<<endl;
    		ma[x].push_back(y);
    		ma[y].push_back(x);
    	}
    	else
    	{
    		// cout<<"Cycle Edge "<<x<<' '<<y<<endl;
    		join1(x,y);
    	}
    }
    // cout<<"Tree Input:\n";
    for(int i=1;i<=n;i++)
    	if(pa[i][0]==0)
		    dfs(i,i);
	// cout<<"Cycle Input:"<<endl;
    for(int y=1;y<=n;y++)
    {
    	int x=get1(y);
    	// cout<<y<<' '<<x<<endl;
    	int c=lca(x,y);
		if(h[Up[x]]>h[c])
		{
			Up[x]=c;
		}
		if(h[Up[y]]>h[c])
		{
			Up[y]=c; 
		}
    }
    // cout<<"Bridge Edges:\n";
    for(int i=1;i<=n;i++)
    	if(pa[i][0]==i)
		    solve(i,i);
    return 0;
}
# Verdict Execution time Memory Grader output
1 Correct 1 ms 4696 KB Output is correct
2 Correct 2 ms 4700 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 3 ms 5468 KB Output is correct
2 Correct 3 ms 5464 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 26 ms 11844 KB Output is correct
2 Correct 18 ms 11356 KB Output is correct
# Verdict Execution time Memory Grader output
1 Runtime error 38 ms 16464 KB Memory limit exceeded
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Runtime error 66 ms 24936 KB Memory limit exceeded
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Runtime error 121 ms 35736 KB Memory limit exceeded
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Runtime error 181 ms 49420 KB Memory limit exceeded
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Runtime error 229 ms 62568 KB Memory limit exceeded
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Runtime error 254 ms 65536 KB Memory limit exceeded
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Runtime error 299 ms 65536 KB Memory limit exceeded
2 Halted 0 ms 0 KB -