code stringlengths 1 2.06M | language stringclasses 1 value |
|---|---|
#ifndef _DATA_SET_LOADER_H_
#define _DATA_SET_LOADER_H_
#include "DataStructure.h"
#include <istream>
#include <fstream>
// reads an external dataset file, creates and builds up a new data structure
DataStructure* loadDataSet(const char* filepath);
#endif | C++ |
#ifndef _FORMAL_CONTEXT_H_
#define _FORMAL_CONTEXT_H_
#include "OAPair.h"
#include <vector>
// local formal context
class FormalContext {
public:
FormalContext() : processedNo(0) {}
FormalContext(const FormalContext &);
~FormalContext();
unsigned int processedNo;
std::vector<OAPair> data;
};
#endif | C++ |
#ifndef _DATA_STRUCTURE_H_
#define _DATA_STRUCTURE_H_
#include "Attribute.h"
#include "AttributeSet.h"
#include "Object.h"
#include "ObjectSet.h"
#include <vector>
#include <map>
#include <ostream>
// main storage structure
class DataStructure {
public:
DataStructure();
~DataStructure();
// adds an object to set of objects that are the support of attribute attr
void updateAttribute(const Attribute &attr, const Object &obj);
// adds a new object with a complete set of attributes it contains
void addObject(const Object &obj, AttributeSet *aSet);
// returns a set of attributes that are supported by the given object
AttributeSet* getAttributes(const Object &obj) { return _objs[obj-1]; }
// returns a set of objects that support the given attribute
ObjectSet* getObjects(const Attribute &attr) { return _attrs[attr]; }
// returns the set of all attributes
AttributeSet* getAllAtributes() { return this->_allAttrs; }
// returns the set of all objects
ObjectSet* getAllObjects() { return this->_allObjs; }
// prints a brief summary to the out stream
void printSummary(std::ostream &out);
private:
std::map<Attribute, ObjectSet*> _attrs;
std::vector<AttributeSet*> _objs;
AttributeSet* _allAttrs;
ObjectSet* _allObjs;
};
#endif | C++ |
#ifndef _ATTRIBUTE_SET_H_
#define _ATTRIBUTE_SET_H_
#include "Attribute.h"
#include <set>
// set of attributes
class AttributeSet{
public:
AttributeSet(){
this->processed = false;
this->data.clear();
}
AttributeSet(const AttributeSet &other){
this->processed = other.processed;
for(std::set<Attribute>::const_iterator i = other.data.begin(); i != other.data.end(); i++)
this->data.insert(Attribute(*i));
}
~AttributeSet(){};
std::set<Attribute> data;
bool processed;
bool operator==(const AttributeSet &other) const{
if(this->data.size() != other.data.size())
return false;
for(std::set<Attribute>::const_iterator a = this->data.begin(); a != this->data.end(); a++){
bool attributeFound = false;
for(std::set<Attribute>::const_iterator b = other.data.begin(); b != other.data.end(); b++){
if(*b == *a){
attributeFound = true;
break;
}
}
if(attributeFound == false)
return false;
}
return true;
}
bool operator!=(const AttributeSet &other) const{
return !(*this == other);
}
};
#endif | C++ |
#ifndef _OA_PAIR_H_
#define _OA_PAIR_H_
#include "AttributeSet.h"
#include "ObjectSet.h"
// ObjectSet and AttributeSet pair concise representation
typedef std::pair<ObjectSet*, AttributeSet*> OAPair;
// standard comparator
bool OAPairCompare(const OAPair& e1, const OAPair& e2);
#endif | C++ |
#ifndef _KOV_H_
#define _KOV_H_
// declaration of structures used in KOV algorithm implementation
#include "..\common\Attribute.h"
#include "..\common\AttributeSet.h"
#include "..\common\Object.h"
#include "..\common\ObjectSet.h"
#include "..\common\OAPair.h"
#include "..\common\FormalContext.h"
#include "..\common\DataStructure.h"
#include "..\common\DataSetLoader.h"
#include <time.h>
#include <iostream>
#include <fstream>
typedef std:: vector<AttributeSet> DeltaClosure;
// central data structure maintaining data loaded from external data source and
// reference pointers to speed up search operations
extern DataStructure data;
// special version of Closure for empty sets
void ClosureForEmptySet(const AttributeSet &all_attrs, OAPair &oa_pair, FormalContext &local_fc);
// closure computes a closure of OAPair element in local formal context
// represented by local_fc object
void Closure(const AttributeSet &all_attrs, OAPair &oa_pair, FormalContext &local_fc);
// sort_f is a sort function that compares two OAPair elements and returns true
// iff e1 is less or equal than e2, false conversely
void Order(FormalContext &local_fc, bool (*sort_f)(const OAPair &e1, const OAPair &e2) = NULL);
// determine local context for the first iteration of KOV algorithm, i.e.
// w/o considering the minimal support
FormalContext* LocalContext(const OAPair &oa, const FormalContext * const P);
// determine local context for the next iterations of KOV algorithm (KOV-Extend), i.e.
// considering the minimal support and the delta closure
FormalContext* LocalContextMinSup(const OAPair &oa, DeltaClosure deltaClosure, const FormalContext * const P, unsigned int minSup);
void SaveOA(std::ofstream *fc, OAPair &oa, bool asChar);
void PrintOA(OAPair &oa);
void Kov(DataStructure *ds, std::ofstream *fc, unsigned int minSup, unsigned int* counter, bool asChar, bool (*sort_f)(const OAPair &e1, const OAPair &e2) = NULL);
void KovExtend(AttributeSet *allAttributes, FormalContext &p, unsigned int minSup, std::ofstream *fc, AttributeSet* processedSets, unsigned int* counter, bool asChar, bool (*sort_f)(const OAPair &e1, const OAPair &e2) = NULL);
DeltaClosure ClosureDelta(const OAPair &pair, const FormalContext *p);
#endif | C++ |
/**
* Implementation of Closure function
*
* author: Marcin Wachulski
*
*/
#include "KOV.h"
#include <set>
#include <algorithm>
#include <iterator>
void ClosureForEmptySet(const AttributeSet &all_attrs, OAPair &oa_pair, FormalContext &local_fc) {
if (local_fc.data.size() > 0) {
OAPair &fc_last_p = local_fc.data.back();
if (fc_last_p.first->data.size() == oa_pair.first->data.size()) {
local_fc.data.pop_back();
delete fc_last_p.first;
delete fc_last_p.second;
}
}
Closure(all_attrs, oa_pair, local_fc);
}
void Closure(const AttributeSet &all_attrs, OAPair &oa_pair, FormalContext &local_fc) {
AttributeSet *all_FC_attrs = new AttributeSet();
for (std::vector<OAPair>::const_iterator i = local_fc.data.begin();
i != local_fc.data.end(); i++)
all_FC_attrs->data.insert(i->second->data.begin(), i->second->data.end());
// if oa_pair sets are stored in dynamic memory - the following line should be executed
delete oa_pair.second;
oa_pair.second = new AttributeSet(all_attrs);
for (std::set<Attribute>::const_iterator i = all_FC_attrs->data.begin();
i != all_FC_attrs->data.end(); i++)
oa_pair.second->data.erase(*i);
delete all_FC_attrs;
} | C++ |
#include "kov.h"
int main(int argc, char *argv[])
{
_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDOUT );
try {
DataStructure* data = loadDataSet(argv[1]);
data->printSummary(std::cout);
std::ofstream fc(argv[2]);
clock_t start = clock();
unsigned int* counter = new unsigned int(0);
Kov(data,&fc,atoi(argv[3]), counter, strcmp(argv[4],"c")==0);
clock_t end = clock();
std::cout<<"\nTime:"<<(end-start)/1000;
std::cout<<"\nSets:"<<*counter<<"\n";
fc << "\n" << (end-start)/1000<<"\nSets:"<<*counter;
delete counter;
fc.close();
delete data;
}
catch (std::exception e) {
e.what();
}
_CrtDumpMemoryLeaks();
system("PAUSE");
return 0;
}
void Kov(DataStructure *ds, std::ofstream *fc, unsigned int minSup,unsigned int* counter, bool asChar, bool (*sort_f)(const OAPair &e1, const OAPair &e2)){
if(ds->getAllObjects()->data.size() >= minSup){
OAPair oa = std::make_pair( new ObjectSet(*(ds->getAllObjects())), new AttributeSet());
FormalContext *tmpFC = new FormalContext();
for (std::set<Attribute>::const_iterator i = ds->getAllAtributes()->data.begin(); i != ds->getAllAtributes()->data.end(); i++){
if(ds->getObjects(*i)->data.size() >=minSup){
oa.second->data.insert(Attribute(*i));
OAPair tmpPair = std::make_pair( new ObjectSet(*( ds->getObjects(*i) )) , new AttributeSet());
tmpPair.second->data.insert(Attribute(*i));
tmpFC->data.push_back(tmpPair);
}
}
FormalContext* localP = LocalContext(oa, tmpFC);
for (std::vector<OAPair>::iterator i = tmpFC->data.begin(); i != tmpFC->data.end(); i++) {
delete i->first;
delete i->second;
}
delete tmpFC;
ClosureForEmptySet(*(ds->getAllAtributes()),oa,*localP);
SaveOA(fc,oa, asChar);
++(*counter);
AttributeSet* processedSets = new AttributeSet();
KovExtend(ds->getAllAtributes(), *localP, minSup, fc, processedSets,counter,asChar);
delete processedSets;
for (std::vector<OAPair>::iterator i = localP->data.begin(); i != localP->data.end(); i++) {
delete i->first;
delete i->second;
}
delete localP;
delete oa.first;
delete oa.second;
}
}
void PrintOA(OAPair &oa){
ObjectSet *O = oa.first;
AttributeSet *A = oa.second;
std::cout<< "\nO:{ ";
for (std::set<Object>::const_iterator i = O->data.begin(); i != O->data.end(); i++){
std::cout<< *i << " ";
}
std::cout << "}, A:{ ";
for (std::set<Attribute>::const_iterator i = A->data.begin(); i != A->data.end(); i++){
std::cout<< *i << " ";
}
std::cout<< "}";
}
void SaveOA(std::ofstream *fc, OAPair &oa, bool asChar){
//PrintOA(oa);
ObjectSet *O = oa.first;
AttributeSet *A = oa.second;
(*fc) << "<{";
for (std::set<Object>::const_iterator i = O->data.begin(); i != O->data.end(); i++)
(*fc) << *i << " ";
(*fc) << "}>, <{";
for (std::set<Attribute>::const_iterator i = A->data.begin(); i != A->data.end(); i++)
if(asChar){
char c = 'a' -1 + (*i);
(*fc) << c;
}
else
(*fc) << *i << " ";
(*fc) << "}>\n";
}
bool AttributeSetProcessed(const AttributeSet& set, const AttributeSet* sets){
for(std::set<Attribute>::const_iterator attr = set.data.begin(); attr != set.data.end(); ++attr)
for(std::set<Attribute>::const_iterator attr2 = sets->data.begin(); attr2 != sets->data.end(); ++attr2)
if(*attr == *attr2)
return true;
return false;
}
void KovExtend(AttributeSet *allAttributes, FormalContext &p, unsigned int minSup, std::ofstream *fc, AttributeSet *processedSets,unsigned int* counter, bool asChar, bool (*sort_f)(const OAPair &e1, const OAPair &e2)){
Order(p);
for (unsigned int i = 0; i < p.data.size(); i++){
OAPair pair = std::make_pair(new ObjectSet(*(p.data.at(i).first)), new AttributeSet(*p.data.at(i).second));
if(!AttributeSetProcessed(*(p.data.at(i).second), processedSets)){
DeltaClosure deltaClosure = ClosureDelta(p.data.at(i), &p);
bool processed = false;
for (DeltaClosure::const_iterator d = deltaClosure.begin(); d != deltaClosure.end(); d++){
if(AttributeSetProcessed((*d), processedSets)){
processed = true;
break;
}
}
if(processed){
for(std::set<Attribute>::const_iterator attr = p.data.at(i).second->data.begin(); attr != p.data.at(i).second->data.end(); ++attr)
processedSets->data.insert(Attribute(*attr));
}else{
FormalContext* localP = LocalContextMinSup(pair, deltaClosure, &p, minSup);
Order(*localP);
Closure(*allAttributes, pair, *localP);
for(std::set<Attribute>::const_iterator attr = p.data.at(i).second->data.begin(); attr != p.data.at(i).second->data.end(); ++attr)
processedSets->data.insert(Attribute(*attr));
SaveOA(fc,pair, asChar);
++(*counter);
AttributeSet* sets = new AttributeSet(*processedSets);
KovExtend(allAttributes, *localP, minSup, fc, sets, counter,asChar);
delete sets;
for (std::vector<OAPair>::iterator i = localP->data.begin(); i != localP->data.end(); i++) {
delete i->first;
delete i->second;
}
delete localP;
}
}
delete pair.first;
delete pair.second;
}
}
DeltaClosure ClosureDelta(const OAPair &oa, const FormalContext *p){
std::vector<OAPair> deltaClosure;
bool copy = false;
for(std::vector<OAPair>::const_iterator i = p->data.begin(); i!=p->data.end(); i++){
if(copy == false && i->first == oa.first && i->second == oa.second)
copy = true;
if(copy == true){
OAPair pair = std::make_pair(i->first, i->second);
deltaClosure.push_back(pair);
}
}
for(std::set<Object>::const_iterator o = oa.first->data.begin(); o != oa.first->data.end(); o++){
for(std::vector<OAPair>::const_iterator i = deltaClosure.begin(); i != deltaClosure.end();){
bool containsObject = false;
for(std::set<Object>::const_iterator oi = i->first->data.begin(); oi != i->first->data.end(); ++oi){
if(*oi == *o){
containsObject = true;
break;
}
}
if(containsObject == false){
i = deltaClosure.erase(i);
}
else
++i;
}
}
DeltaClosure result;
for(std::vector<OAPair>::const_iterator i = deltaClosure.begin(); i != deltaClosure.end();++i){
AttributeSet set = AttributeSet(*(i->second));
result.push_back(set);
}
return result;
}
| C++ |
/**
* Functions responsible for determining the local context for the KOV algorithm.
*
* author: Maciej Rubikowski
*/
#include "kov.h"
#include <time.h>
#include <Windows.h>
typedef std::pair<ObjectSet, FormalContext*> ObjectContextPair;
typedef std::vector<ObjectContextPair> LocalContextGrouping;
FormalContext* LocalContext(const OAPair &oa, const FormalContext * const P) {
FormalContext *FC = new FormalContext;
LocalContextGrouping G;
ObjectSet *O = oa.first;
AttributeSet *A = oa.second;
ObjectContextPair ocp = std::pair<ObjectSet, FormalContext*>(ObjectSet(), new FormalContext(*P));
G.push_back(ocp);
for (std::set<Object>::const_iterator o = O->data.begin(); o != O->data.end(); ++o) {
LocalContextGrouping set_S;
ObjectSet *Z = NULL;
FormalContext *E = NULL;
for (std::vector<ObjectContextPair>::iterator j = G.begin(); j != G.end();) {
Z = &j->first;
E = j->second;
ObjectSet os = *Z;
os.data.insert(*o);
ObjectContextPair S = std::pair<ObjectSet, FormalContext*>(os, new FormalContext);
for (std::vector<OAPair>::iterator YB = E->data.begin(); YB != E->data.end(); ) {
// remove all y from Y such that y precedes o
// and BTW check if o belongs to Y
ObjectSet *Y = YB->first;
AttributeSet *B = YB->second;
bool oInY = false;
for (std::set<Object>::iterator y = Y->data.begin(); y != Y->data.end(); ) {
if (*y < *o)
y = Y->data.erase(y);
else if (*y == *o) {
oInY = true;
break;
} else {
++y;
}
}
// if object o belongs to Y...
if (oInY) {
Y->data.erase(*o); // remove o from Y
S.second->data.push_back(*YB);
YB = E->data.erase(YB); // remove (Y, B) from E
} else
++YB;
}
// if the second element of S is different from null_set then
if (!S.second->data.empty()) {
set_S.push_back(S);
if (E->data.empty()) {
j = G.erase(j); //delete E
delete E;
} else {
++j;
}
} else {
delete S.second;
++j;
}
}
G.insert(G.end(), set_S.begin(), set_S.end());
}
// prepare P<O, A>
for (LocalContextGrouping::iterator it = G.begin(); it != G.end();) {
if (it->second->data.empty()) {
++it;
continue;
}
ObjectSet *Z = new ObjectSet(it->first);
AttributeSet *D = new AttributeSet;
for (std::vector<OAPair>::iterator it2 = it->second->data.begin(); it2 != it->second->data.end(); ++it2)
D->data.insert(it2->second->data.begin(), it2->second->data.end());
D->processed = false;
FC->data.push_back(OAPair(Z, D));
++it;
}
// clean up
for(LocalContextGrouping::iterator it = G.begin(); it != G.end(); ++it) {
for(std::vector<OAPair>::iterator it2 = it->second->data.begin(); it2 != it->second->data.end(); ++it2) {
delete it2->first;
delete it2->second;
}
delete it->second;
}
return FC;
}
FormalContext* LocalContextMinSup(const OAPair &oa, DeltaClosure deltaClosure, const FormalContext * const P, unsigned int minSup) {
LocalContextGrouping G;
FormalContext *FC = new FormalContext;
ObjectSet *O = oa.first;
AttributeSet *A = oa.second;
FormalContext *FC2 = new FormalContext;
// prepare the initial grouping wrt DeltaClosure
for (std::vector<OAPair>::const_iterator it = P->data.begin(); it != P->data.end(); ++it) {
bool found = false;
for (std::vector<AttributeSet>::iterator it2 = deltaClosure.begin(); it2 != deltaClosure.end(); ++it2) {
if (*it2 == *(it->second)) {
found = true;
break;
}
}
if (found)
continue;
else {
OAPair oap = OAPair(new ObjectSet(*it->first), new AttributeSet(*it->second));
FC2->data.push_back(oap);
}
}
ObjectContextPair ocp = std::pair<ObjectSet, FormalContext*>(ObjectSet(), FC2);
G.push_back(ocp);
for (std::set<Object>::const_iterator o = O->data.begin(); o != O->data.end(); ++o) {
LocalContextGrouping set_S;
ObjectSet *Z = NULL;
FormalContext *E = NULL;
for (std::vector<ObjectContextPair>::iterator j = G.begin(); j != G.end();) {
Z = &j->first;
E = j->second;
ObjectSet os = *Z;
os.data.insert(*o);
ObjectContextPair S = std::make_pair<ObjectSet, FormalContext*>(os, new FormalContext);
for (std::vector<OAPair>::iterator YB = E->data.begin(); YB != E->data.end();) {
// remove all y from Y such that y precedes o
// and BTW check if o belongs to Y
ObjectSet *Y = YB->first;
AttributeSet *B = YB->second;
bool oInY = false;
for (std::set<Object>::iterator y = YB->first->data.begin(); y != YB->first->data.end();) {
if (*y < *o)
y = Y->data.erase(y);
else if (*y == *o) {
oInY = true;
break;
} else {
++y;
}
}
// if object o belongs to Y...
if (oInY) {
Y->data.erase(*o); // remove o from Y
S.second->data.push_back(*YB);
YB = E->data.erase(YB); // remove (Y, B) from E
} else
++YB;
}
// if the second element of S is different from null_set then
if (!S.second->data.empty()) {
set_S.push_back(S);
if (E->data.empty()) {
j = G.erase(j);
delete E;
} else {
++j;
}
} else {
delete S.second;
++j;
}
}
G.insert(G.end(), set_S.begin(), set_S.end());
}
// prepare InfrAttrSet
AttributeSet *ias = new AttributeSet();
for (LocalContextGrouping::iterator it = G.begin(); it != G.end();++it) {
if (it->first.data.size() < minSup)
for (std::vector<OAPair>::iterator it2 = it->second->data.begin(); it2 != it->second->data.end(); ++it2) {
ias->data.insert(it2->second->data.begin(), it2->second->data.end());
}
}
if (!ias->data.empty()) {
ias->processed = true;
FC->data.push_back(OAPair(new ObjectSet, ias));
} else {
delete ias;
}
bool isProcessed = false;
// prepare P<O, A>
for (LocalContextGrouping::iterator it = G.begin(); it != G.end();) {
if (it->second->data.empty() || it->first.data.size() < minSup) {
++it;
continue;
}
ObjectSet *Z = new ObjectSet(it->first);
AttributeSet *D = new AttributeSet;
for (std::vector<OAPair>::iterator it2 = it->second->data.begin(); it2 != it->second->data.end(); ++it2)
D->data.insert(it2->second->data.begin(), it2->second->data.end());
D->processed = false;
FC->data.push_back(OAPair(Z, D));
++it;
}
// clean up
for(LocalContextGrouping::iterator it = G.begin(); it != G.end(); ++it) {
for(std::vector<OAPair>::iterator it2 = it->second->data.begin(); it2 != it->second->data.end(); ++it2) {
delete it2->first;
delete it2->second;
}
delete it->second;
}
return FC;
} | C++ |
/**
* Implementation of Order function
*
* author: Marcin Wachulski
*
*/
#include "KOV.h"
#include <algorithm>
void Order(FormalContext &local_fc, bool (*sort_f)(const OAPair &e1, const OAPair &e2)) {
if (local_fc.data.size() < 2)
return;
std::sort(local_fc.data.begin(), local_fc.data.end(), OAPairCompare);
} | C++ |
#include <iostream>
#include <vector>
using namespace std;
template <typename T>
void read(vector <T> &data) {
int length;
cin >> length;
if (length == 4)
throw 1;
data.resize(length);
for (int i = 0; i < length; ++i) {
cin >> data[i];
}
return;
}
template <typename iterator, typename T>
iterator partition(iterator begin, iterator end, T value) {
if (end - begin == 0)
return begin;
iterator left = begin, right = end - 1;
while (left != right) {
while (left != right && *left < value) {
++left;
}
while (left != right && *right >= value) {
--right;
}
swap(*left, *right);
if (left == right || left == right - 1)
break;
++left, --right;
}
if (*begin >= value)
return begin;
while (*left >= value && left != begin)
--left;
while (left != end && *left < value)
++left;
return left;
}
int main() {
vector <int> data;
read(data);
int value;
cin >> value;
int less = partition(data.begin(), data.end(), value) - data.begin();
cout << less << endl << data.size() - less << endl;
} | C++ |
#include <fstream>
#include <vector>
using namespace std;
template <typename T>
void read(vector <T> &data) {
int length;
ifstream in("input.txt");
in >> length;
data.resize(length);
for (int i = 0; i < length; ++i) {
in >> data[i];
}
return;
}
template <typename T>
void max_to_end(vector <T> &data, int length) {
int position = 0;
if (length == 0) {
return;
}
for (int i = 0; i < length; ++i) {
if (data[i] > data[position]) {
position = i;
}
}
swap(data[position], data[length - 1]);
return;
}
template <typename T>
void sort(vector <T> &data) {
for (int i = data.size(); i > 0; --i) {
max_to_end(data, i);
}
}
template <typename T>
void print(vector <T> &data) {
ofstream out("output.txt");
for (int i = 0; i < data.size(); ++i) {
out << data[i] << ' ';
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
vector <int> data;
read(data);
sort(data);
print(data);
} | C++ |
#include <fstream>
#include <vector>
using namespace std;
template <typename T>
void read(vector <T> &data) {
int length;
ifstream in("input.txt");
in >> length;
data.resize(length);
for (int i = 0; i < length; ++i) {
in >> data[i];
}
return;
}
template <typename T>
void max_to_end(vector <T> &data) {
int position = 0;
if (data.empty()) {
return;
}
for (int i = 0; i < data.size(); ++i) {
if (data[i] > data[position]) {
position = i;
}
}
swap(data[position], data.back());
return;
}
template <typename T>
void print(vector <T> &data) {
ofstream out("output.txt");
for (int i = 0; i < data.size(); ++i) {
out << data[i] << ' ';
}
return;
}
int main() {
vector <int> data;
read(data);
max_to_end(data);
print(data);
} | C++ |
#include <iostream>
#include <vector>
using namespace std;
template <typename T>
void read(vector <T> &data) {
int length;
cin >> length;
data.resize(length);
for (int i = 0; i < length; ++i) {
cin >> data[i];
}
return;
}
template <typename iterator, typename T>
iterator partition(iterator begin, iterator end, T value) {
if (end - begin == 0)
return begin;
iterator left = begin, right = end - 1;
while (left != right) {
while (left != right && *left < value) {
++left;
}
while (left != right && *right >= value) {
--right;
}
swap(*left, *right);
if (left == right || left == right - 1)
break;
++left, --right;
}
if (*begin >= value)
return begin;
while (*left >= value && left != begin)
--left;
while (left != end && *left < value)
++left;
return left;
}
template <typename iterator>
void sort(iterator begin, iterator end) {
if (end - begin <= 1)
return;
int length = end - begin;
int value = *(begin + rand() % length);
iterator middle = partition(begin, end, value);
sort(begin, middle);
while (middle != end && *middle == value)
++middle;
sort(middle, end);
}
template <typename T>
void print(vector <T> &data) {
for (int i = 0; i < data.size(); ++i) {
cout << data[i] << ' ';
}
cout << endl;
return;
}
int main() {
vector <int> data;
read(data);
srand(time(NULL));
sort(data.begin(), data.end());
print(data);
}
| C++ |
#include <iostream>
#include <vector>
using namespace std;
template <typename T>
void read(vector <T> &data) {
int length;
cin >> length;
data.resize(length);
for (int i = 0; i < length; ++i) {
cin >> data[i];
}
return;
}
template <typename T>
void merge(T first_begin,
T first_end,
T second_begin,
T second_end,
T result_begin,
T result_end) {
T buffer = result_begin;
auto first = first_begin, second = second_begin;
while (1) {
if (first == first_end && second == second_end) {
break;
}
else if (first == first_end) {
*buffer = *second;
++second, ++buffer;
} else if (second == second_end) {
*buffer = *first;
++first, ++buffer;
} else if (*first < *second) {
*buffer = *first;
++first, ++buffer;
} else {
*buffer = *second;
++second, ++buffer;
}
}
}
template <typename T>
void print(vector <T> &data) {
for (int i = 0; i < data.size(); ++i) {
cout << data[i] << ' ';
}
return;
}
int main() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(0);
vector <int> a, b;
read(a);
read(b);
vector <int> result(a.size() + b.size());
merge(a.begin(), a.end(), b.begin(), b.end(), result.begin(), result.end());
print(result);
} | C++ |
#include <iostream>
#include <vector>
using namespace std;
template <typename T>
void read(vector <T> &data) {
int length;
cin >> length;
data.resize(length);
for (int i = 0; i < length; ++i) {
cin >> data[i];
}
return;
}
template <typename T>
void merge(T first_begin, T first_end, T second_begin, T second_end, T destination_begin, T destination_end) {
T first = first_begin, second = second_begin, destination = destination_begin;
while (1) {
if (first == first_end && second == second_end)
break;
if (first == first_end) {
*destination = *second;
++destination, ++second;
} else if (second == second_end) {
*destination = *first;
++destination, ++first;
} else if (*first < *second) {
*destination = *first;
++destination, ++first;
} else {
*destination = *second;
++destination, ++second;
}
}
return;
}
template <typename T>
void copy(T begin, T end, T destination_begin, T destination_end) {
T current = begin, destination = destination_begin;
while (current != end) {
*destination = *current;
++destination, ++current;
}
return;
}
template <typename T>
void sort(T begin, T end, T bufer_begin, T bufer_end) {
if (end - begin <= 1) {
return;
}
sort(begin, begin + (end - begin) / 2, bufer_begin, bufer_begin + (bufer_end - bufer_begin) / 2);
sort(begin + (end - begin) / 2, end, bufer_begin + (bufer_end - bufer_begin) / 2, bufer_end);
merge(begin, begin + (end - begin) / 2, begin + (end - begin) / 2, end, bufer_begin, bufer_end);
copy(bufer_begin, bufer_end, begin, end);
}
template <typename T>
void print(vector <T> &data) {
for (int i = 0; i < data.size(); ++i) {
cout << data[i] << ' ';
}
return;
}
int main() {
vector <int> data;
read(data);
vector <int> bufer(data.size());
sort(data.begin(), data.end(), bufer.begin(), bufer.end());
print(data);
} | C++ |
#include <bits/stdc++.h>
using namespace std;
bool dfs(int v, vector <vector <int> > &g, vector <int> &p, vector <bool> &u) {
u[v] = 1;
for (auto to: g[v]) {
if (p[to] == -1) {
p[to] = v;
return 1;
}
if (u[p[to]]) {
continue;
}
if (dfs(p[to], g, p, u)) {
p[to] = v;
return 1;
}
}
return 0;
}
int main() {
int n, m;
cin >> n >> m;
vector <string> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector <vector <int> > b(n, vector <int>(m, -1));
int left = 0, right = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == '#') {
if ((i + j) % 2) {
b[i][j] = left++;
} else {
b[i][j] = right++;
}
}
}
}
if (left != right) {
cout << "No" << endl;
return 0;
}
vector <vector <int> > g(left);
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == '#' && (i + j) % 2 == 1) {
for (int d = 0; d < 4; ++d) {
if (i + dx[d] >= 0 && i + dx[d] < n && j + dy[d] >= 0 && j + dy[d] < m && b[i + dx[d]][j + dy[d]] >= 0) {
g[b[i][j]].push_back(b[i + dx[d]][j + dy[d]]);
}
}
}
}
}
vector <int> p(right, -1);
vector <bool> s(left), u(left);
for (int i = 0; i < left; ++i) {
for (auto to: g[i]) {
if (p[to] == -1) {
p[to] = i;
s[i] = 1;
break;
}
}
}
for (int i = 0; i < left; ++i) {
if (!s[i]) {
u.assign(n, 0);
s[i] = dfs(i, g, p, u);
}
}
for (int i = 0; i < left; ++i) {
if (!s[i]) {
cout << "No";
return 0;
}
}
cout << "Yes";
return 0;
} | C++ |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9 + 1;
struct node {
int value;
char color;
node *left, *right;
node *parent;
node() : value(inf + 1), color(0), left(NULL), right(NULL), parent(NULL) {}
};
typedef node* tree;
void right_turn(tree &t, tree &father, tree &root, tree &uncle) {
if (root->parent != NULL) {
if (root->parent->left == root) {
root->parent->left = father;
} else {
root->parent->right = father;
}
} else {
T = father;
}
tree gamma = father->right;
father->parent = root->parent;
father->right = root;
father->color = 0;
root->parent = father;
root->left = gamma;
if (gamma)
gamma->parent = root;
root->color = 1;
return;
}
void right_in_turn(tree &t, tree &father, tree &root, tree &uncle) {
if (root->parent) {
if (root->parent->left == root) {
root->parent->left = t;
} else {
root->parent->right = t;
}
} else {
T = t;
}
tree alpha = t->left, beta = t->right;
t->parent = root->parent;
t->color = 0;
t->left = father;
t->right = root;
father->right = alpha;
if (alpha)
alpha->parent = father;
father->parent = t;
root->parent = t;
root->left = beta;
if (beta)
beta->parent = root;
root->color = 1;
return;
}
void left_turn(tree &t, tree &father, tree &root, tree &uncle) {
if (root->parent != NULL) {
if (root->parent->left == root) {
root->parent->left = father;
} else {
root->parent->right = father;
}
} else {
T = father;
}
tree gamma = father->left;
father->parent = root->parent;
father->left = root;
father->right = t;
father->color = 0;
root->right = gamma;
root->parent = father;
if (gamma)
gamma->parent = root;
root->color = 1;
return;
}
void left_in_turn(tree &t, tree &father, tree &root, tree &uncle) {
if (root->parent != NULL) {
if (root->parent->left == root) {
root->parent->left = t;
} else {
root->parent->right = t;
}
} else {
T = t;
}
tree delta = t->left, eps = t->right;
t->parent = root->parent;
t->left = root;
t->right = father;
t->color = 0;
root->right = delta;
if (delta)
delta->parent = root;
root->color = 1;
root->parent = t;
father->left = eps;
if (eps)
eps->parent = father;
father->parent = t;
return;
}
void balance(tree &t) {
while (t->parent != NULL) {
if (!t->parent->color) {
return;
}
if (t->parent->parent == NULL) {
t->parent->color = 0;
return;
}
tree root = t->parent->parent;
bool left = (root->left == t->parent);
tree uncle = (left ? root->right : root->left);
tree father = t->parent;
if (uncle && uncle->color) {
uncle->color = 0;
root->color = 1;
t->parent->color = 0;
t = t->parent->parent;
continue;
}
bool left2 = (father->left == t);
if (left && left2) {
first_turn(t, father, root, uncle);
}
if (left && !left2) {
second_turn(t, father, root, uncle);
}
if (!left && !left2) {
third_turn(t, father, root, uncle);
}
if (!left && left2) {
fourth_turn(t, father, root, uncle);
}
}
}
void insert(int value, tree &T) {
tree t = T, pr = NULL;
while (t != NULL) {
if (t->value == value) {
return;
} else if (t->value < value) {
pr = t, t = t->right;
} else {
pr = t, t = t->left;
}
}
t = new node();
t->value = value;
t->color = 1;
t->parent = pr;
if (pr) {
if (pr->value < value) {
pr->right = t;
} else {
pr->left = t;
}
}
balance(t);
t->color = 0;
T = t;
}
bool check(int value, tree t) {
while (t) {
if (t->value == value) {
return 1;
}
if (t->value < value) {
t = t->right;
} else {
t = t->left;
}
}
return 0;
}
int check_tree(tree t) {
if (t == NULL) {
return 0;
}
int len = 1 - t->color;
int x = check_tree(t->left), y = check_tree(t->right);
if (x == -1 || x != y) {
return -1;
}
return x + len;
}
int main() {
freopen("input.txt", "r", stdin);
int n;
scanf("%d", &n);
tree T = NULL;
while (n-- > 0) {
int t, v;
scanf("%d%d", &t, &v);
if (t == 0) {
insert(v, T);
} else {
puts(check(v, T) ? "Yes" : "No");
}
}
}
| C++ |
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define rs resize
#define mp make_pair
#define pi 3.1415926535897932384626433832795
#define sz(a) (int)(a).size()
#define Sort(a) sort((a).begin(), (a).end())
#define Reverse(a) reverse((a).begin(), (a).end())
#define sf scanf
#define pf printf
#define ms(a, x) memset((a), (x), sizeof(a))
typedef vector <int> vi;
typedef vector <vi> vvi;
typedef vector <vvi> vvvi;
typedef vector <vvvi> vvvvi;
typedef vector <bool> vb;
typedef vector <vb> vvb;
typedef vector <vvb> vvvb;
typedef vector <vvvb> vvvvb;
typedef long long ll;
typedef vector <ll> vl;
typedef vector <vl> vvl;
typedef vector <vvl> vvvl;
typedef vector <vvvl> vvvvl;
typedef pair <int, int> ii;
typedef vector <ii> vii;
typedef vector <vii> vvii;
typedef pair <int, ll> il;
typedef vector <il> vil;
typedef vector <vil> vvil;
typedef pair <ll, int> li;
typedef vector <li> vli;
typedef vector <vli> vvli;
typedef set <int> si;
typedef set <li> sli;
typedef set <il> sil;
typedef vector <string> vs;
typedef vector <vs> vvs;
typedef vector <vvs> vvvs;
typedef map <char, int> mci;
typedef pair <ll, ll> pll;
const ll inf = (ll)1e18;
struct edge {
int to, back;
ll c, f;
edge() {}
edge(int to, int c, int f, int back) : to(to), c(c), f(f), back(back) {}
};
void bfs(int s, vector <vector <edge> > &g, vector <int> &d, ll max_edge) {
d.assign(sz(g), (int)1e9);
d[s] = 0;
queue <int> q;
q.push(s);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < sz(g[v]); ++i) {
if (g[v][i].c > g[v][i].f && d[g[v][i].to] > d[v] + 1 && g[v][i].c - g[v][i].f >= max_edge) {
d[g[v][i].to] = d[v] + 1;
q.push(g[v][i].to);
}
}
}
return;
}
ll dfs(int v, vector <vector <edge> > &g, vb &u, vi &d, ll flow, int t, ll max_edge) {
u[v] = 1;
if (v == t) {
return flow;
}
for (auto &e: g[v]) {
if (u[e.to] || d[e.to] != d[v] + 1 || e.c == e.f || e.c - e.f < max_edge) {
continue;
}
ll pushed = dfs(e.to, g, u, d, min(flow, e.c - e.f), t, max_edge);
if (pushed > 0) {
e.f += pushed;
g[e.to][e.back].f -= pushed;
return pushed;
}
}
return 0;
}
ll dinic(int s, int t, vector <vector <edge> > &g) {
int n = sz(g);
vi d(n);
ll flow = 0;
vb u(n);
for (ll max_edge = (ll)5e8; max_edge > 0; max_edge /= 2) {
while (1) {
bfs(s, g, d, max_edge);
if (d[t] == (int)1e9) {
break;
}
ll pushed = 1;
u.assign(n, 0);
while (pushed = dfs(s, g, u, d, inf, t, max_edge)) {
u.assign(n, 0);
flow += pushed;
}
}
}
return flow;
}
void add_edge(vector <vector <edge> > &g, int v, int to, int c) {
g[v].pb(edge(to, c, 0, sz(g[to])));
g[to].pb(edge(v, 0, 0, sz(g[v]) - 1));
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int l = 0, r = 1e8;
int n, m;
cin >> n >> m;
vector <int> a(n + 1);
int sum = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sum += a[i];
}
vector <vector <edge> > G(n + 2);
vector <vector <int> > g(n + 1);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
g[x].pb(y);
}
while (l < r) {
int M = (l + r) / 2;
//cerr << "Graph" << endl;
for (int i = 1; i <= n; ++i) {
add_edge(G, 0, i, a[i]);
//cerr << 0 << ' ' << i << ' ' << a[i] << endl;
}
for (int v = 1; v <= n; ++v) {
for (int to: g[v]) {
add_edge(G, v, to, (int)1e9);
//cerr << v << ' ' << to << ' ' << (int)1e9 << endl;
}
}
for (int v = 1; v <= n; ++v) {
add_edge(G, v, n + 1, M);
//cerr << v << ' ' << n + 1 << ' ' << M << endl;
}
ll fl = dinic(0, n + 1, G);
//cerr << fl << endl << endl;
if (fl == sum) {
r = M;
} else {
l = M + 1;
}
for (int i = 0; i < n + 2; ++i) {
G[i].clear();
}
}
cout << l;
return 0;
} | C++ |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct heap {
int k;
vector <T> a;
heap(int k) : k(k) {
a.reserve(10000000);
}
void sift_up(int v) {
if (v == 0) {
return;
}
int p = (v - 1) / k;
if (a[p] > a[v]) {
swap(a[p], a[v]);
sift_up(p);
}
}
void sift_down(int v) {
int best = v;
for (int i = v * k + 1; i <= v * k + k && i < a.size(); ++i) {
if (a[i] < a[best]) {
best = i;
}
}
if (best == v) {
return;
}
swap(a[v], a[best]);
sift_down(best);
}
void insert(T x) {
a.push_back(x);
sift_up(a.size() - 1);
}
void extract_min() {
swap(a[0], a.back());
a.pop_back();
if (!a.empty())
sift_down(0);
}
T get_min() {
return a[0];
}
bool empty() {
return a.empty();
}
};
const int INF = (int)1e9;
int main() {
//freopen("input.txt", "r", stdin);
int n;
cin >> n;
vector <vector <pair <int, int> > > g(n);
for (int i = 0; i < n; ++i) {
int m;
cin >> m;
for (int j = 0; j < m; ++j) {
int x, y;
cin >> x >> y;
--y;
g[i].push_back({y, x});
}
}
vector <pair <int, int> > ans;
int ans_len = -1;
for (int v = 0; v < n; ++v) {
vector <int> d(n, INF);
heap <pair <int, int> > h(2);
d[v] = 0;
h.insert({d[v], v});
while (!h.empty()) {
int u = h.get_min().second, D = h.get_min().first;
h.extract_min();
if (D != d[u]) {
continue;
}
for (auto e: g[u]) {
if (d[e.first] > d[u] + e.second) {
d[e.first] = d[u] + e.second;
h.insert({d[e.first], e.first});
}
}
}
int len = 0;
for (int i = 0; i < n; ++i) {
if (d[i] != INF) {
len = max(len, d[i]);
}
}
if (ans_len > len) {
continue;
}
if (ans_len < len) {
ans.clear();
ans_len = len;
}
if (ans_len == len) {
for (int i = 0; i < n; ++i) {
if (d[i] == len) {
ans.push_back({v, i});
}
}
}
}
cout << ans_len << endl;
for (auto x: ans) {
cout << x.first + 1 << ' ' << x.second + 1 << endl;
}
return 0;
} | C++ |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::swap;
using std::vector;
struct edge {
int v, u, cost;
edge() {}
edge(int v, int u, int cost) : v(v), u(u), cost(cost) {}
};
void input(int &n, vector <edge> &graph) {
int m, k;
cin >> n >> m >> k;
for (int i = 0; i < m * 2; ++i) {
int x, y, c;
cin >> x >> y >> c;
if (x >= y) {
continue;
}
graph.push_back(edge(x, y, c));
}
for (int i = 1; i <= k; ++i) {
graph.push_back(edge(0, i, 0));
}
return;
}
struct dsu {
vector <int> ancestor, rank;
dsu() {}
dsu(int n) : ancestor(n + 1), rank(n + 1) {
for (int i = 0; i <= n; ++i) {
ancestor[i] = i;
}
}
int get(int v) {
if (ancestor[v] == v) {
return v;
}
return ancestor[v] = get(ancestor[v]);
}
bool unite(int v, int u) {
v = get(v);
u = get(u);
if (v == u) {
return 0;
}
if (rank[v] < rank[u]) {
swap(v, u);
}
ancestor[u] = v;
if (rank[v] == rank[u]) {
++rank[v];
}
return 1;
}
};
void solve(int n, vector <edge> &a) {
dsu DSU(n);
sort(a.begin(), a.end(), [](edge e1, edge e2) {
return e1.cost < e2.cost;
});
int answer = 0;
for (auto e: a) {
if (DSU.unite(e.v, e.u) && e.cost > 0) {
answer += e.cost;
}
}
cout << answer << endl;
return;
}
int main() {
int n;
vector <edge> a;
input(n, a);
solve(n, a);
return 0;
}
| C++ |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::set;
using std::vector;
using std::pair;
using std::max;
void read(int &n, vector <int> &t, vector <vector <int> > &g) {
cin >> n;
t.resize(n + 1);
g.resize(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> t[i];
if (t[i] == 0) {
g[0].push_back(i);
}
int sz;
cin >> sz;
g[i].resize(sz);
for (int j = 0; j < sz; ++j) {
cin >> g[i][j];
}
}
}
const int INF = (int)1e9;
void dfs(int v, vector <vector <int> > &g, vector <int> &t, int T, vector <bool> &u, int &cnt) {
++cnt;
u[v] = 1;
for (auto to: g[v]) {
if (!u[to] && t[to] <= T) {
dfs(to, g, t, T, u, cnt);
}
}
}
int solve(int n, vector <int> &t, vector <vector <int> > &g) {
int c = -1;
vector <bool> u(n + 1);
dfs(0, g, t, INF, u, c);
if (c < (n + 1) / 2) {
return -1;
}
int L = 0, R = INF;
while (L < R) {
int M = (L + R) / 2;
u.assign(n + 1, 0);
c = -1;
dfs(0, g, t, M, u, c);
if (c < (n + 1) / 2) {
L = M + 1;
}
else {
R = M;
}
}
return L;
}
int main() {
//freopen("input.txt", "r", stdin);
int n;
vector <int> t;
vector <vector <int> > g;
read(n, t, g);
cout << solve(n, t, g) << endl;
}
| C++ |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector <pair <int, int> > a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
}
sort(a.begin(), a.end(), [](pair <int, int> a, pair <int, int> b) {
return a.second > b.second;
});
long long s = 0;
long long ans = 0;
for (int i = 0; i < n; ++i) {
s += a[i].first;
ans = max(ans, s + a[i].second);
}
cout << ans;
return 0;
} | C++ |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::swap;
using std::vector;
struct edge {
int v, u, cost;
edge() {}
edge(int v, int u, int cost) : v(v), u(u), cost(cost) {}
};
void input(int &n, vector <edge> &graph) {
int m;
cin >> n >> m;
graph.resize(m);
for (int i = 0; i < m; ++i) {
cin >> graph[i].v >> graph[i].u >> graph[i].cost;
}
return;
}
struct dsu {
vector <int> ancestor, rank;
dsu() {}
dsu(int n) : ancestor(n + 1), rank(n + 1) {
for (int i = 0; i <= n; ++i) {
ancestor[i] = i;
}
}
int get(int v) {
if (ancestor[v] == v) {
return v;
}
return ancestor[v] = get(ancestor[v]);
}
bool unite(int v, int u) {
v = get(v);
u = get(u);
if (v == u) {
return 0;
}
if (rank[v] < rank[u]) {
swap(v, u);
}
ancestor[u] = v;
if (rank[v] == rank[u]) {
++rank[v];
}
return 1;
}
};
void solve(int n, vector <edge> &a) {
dsu DSU(n);
sort(a.begin(), a.end(), [](edge e1, edge e2) {
return e1.cost < e2.cost;
});
int answer = 0;
int cnt = 0;
for (auto e: a) {
if (DSU.unite(e.v, e.u) && e.cost > 0) {
answer += e.cost;
++cnt;
}
}
cout << answer << ' ' << cnt << endl;
return;
}
int main() {
int n;
vector <edge> a;
input(n, a);
solve(n, a);
return 0;
}
| C++ |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::vector;
void dfs(int v, vector <int> &x, vector <int> &y, int k, vector <bool> &used) {
used[v] = 1;
for (int i = 0; i < used.size(); ++i) {
if (!used[i] && (x[i] - x[v]) * (x[i] - x[v]) + (y[i] - y[v]) * (y[i] - y[v]) <= k * k) {
dfs(i, x, y, k, used);
}
}
}
int main() {
int n, k;
cin >> n >> k;
vector <int> x(n), y(n);
for (int i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
}
vector <bool> used(n, 0);
dfs(0, x, y, k, used);
for (int i = 0; i < n; ++i) {
if (!used[i]) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
} | C++ |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::vector;
enum COLORS{
BLACK = 2,
WHITE = 0,
GREY = 1
};
void dfs(int v, vector <vector <int> > &graph, vector <COLORS> &color, vector <int> &topsort, bool found_cycles) {
color[v] = GREY;
for (int to: graph[v]) {
if (!color[to])
dfs(to, graph, color, topsort, found_cycles);
else if (color[to] == GREY) {
found_cycles = 1;
}
}
topsort.push_back(v);
color[v] = BLACK;
}
void input(int &n, int &a, int &b, vector <vector <int> > &graph) {
cin >> n >> a >> b;
graph.resize(n * 2);
while (a-- > 0) {
int i, j;
cin >> i >> j;
--i, --j;
graph[i + n].push_back(j);
}
while (b-- > 0) {
int i, j;
cin >> i >> j;
--i, --j;
graph[j].push_back(i + n);
graph[i].push_back(j + n);
}
for (int i = 0; i < n; ++i) {
graph[i].push_back(i + n);
}
}
bool solve(int n, vector <vector <int> > &graph, vector <int> &x, vector <int> &y) {
vector <COLORS> color(n * 2);
vector <int> topsort;
bool found_cycles = 0;
for (int i = 0; i < n; ++i) {
if (!color[i])
dfs(i, graph, color, topsort, found_cycles);
}
reverse(topsort.begin(), topsort.end());
for (int i = 0; i < n * 2; ++i) {
if (topsort[i] >= n) {
y[topsort[i] - n] = i;
} else {
x[topsort[i]] = i;
}
}
return found_cycles;
}
void output(const vector <int> &x, const vector <int> &y) {
for (int i = 0; i < x.size(); ++i) {
cout << x[i] << ' ' << y[i] << endl;
}
return;
}
int main() {
int n, a, b;
vector <vector <int> > graph;
input(n, a, b, graph);
vector <int> x(n), y(n);
if (solve(n, graph, x, y)) {
output(x, y);
}
else {
cout << "Impossible";
}
return 0;
} | C++ |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::pair;
using std::queue;
using std::vector;
const int dx[4] = { 1, 0, -1, 0 };
const int dy[4] = { 0, 1, 0, -1 };
const int inf = (int)1e9;
int main() {
int m, n;
cin >> m >> n;
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
--x1, --y1, --x2, --y2;
vector <vector <int> > a(m, vector <int>(n, 0));
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
cin >> a[i][j];
}
}
queue <pair <int, int> > q;
q.push({ x1, y1 });
vector <vector <int> > d(m, vector <int>(n, inf));
d[x1][y1] = 0;
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < 4; ++i) {
if (!(x + dx[i] >= 0 && x + dx[i] < m && y + dy[i] >= 0 && y + dy[i] < n))
continue;
if (a[x + dx[i]][y + dy[i]])
continue;
if (d[x + dx[i]][y + dy[i]] <= d[x][y] + 1)
continue;
d[x + dx[i]][y + dy[i]] = d[x][y] + 1;
q.push({ x + dx[i], y + dy[i] });
}
}
if (d[x2][y2] == inf) {
cout << "NO";
} else {
cout << d[x2][y2];
}
} | C++ |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::min;
using std::vector;
const int infinity = (int)1e9 + 1;
int main() {
int n, m;
cin >> n >> m;
vector <vector <int> > grid(n, vector <int>(m, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> grid[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (i + j == 0) {
continue;
}
grid[i][j] += min((i > 0 ? grid[i - 1][j] : infinity), (j > 0 ? grid[i][j - 1] : infinity));
}
}
cout << grid[n - 1][m - 1];
}
| C++ |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::vector;
const int MODULO = 268435459;
int main() {
int n, m;
cin >> n >> m;
vector <vector <int> > grid(n, vector <int>(m, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> grid[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (i + j == 0) {
continue;
}
grid[i][j] *= (i > 0 ? grid[i - 1][j] : 0) + (j > 0 ? grid[i][j - 1] : 0);
grid[i][j] %= MODULO;
}
}
cout << grid[n - 1][m - 1];
}
| C++ |
int main() {
return 0;
}
| C++ |
#include <bits/stdc++.h>
// smart pointers are not very useful here due to high overhead
struct node {
node *prev;
node *ch[2];
int key;
void setCh(int x, node *n) {
ch[x] = n;
if (n != nil)
n->prev = this;
}
bool red;
static node *const nil;
node() {}
private:
node(nullptr_t) {
key = -1;
prev = ch[0] = ch[1] = nullptr;
red = false;
}
static node _nil
};
node node::_nil(nullptr);
node *const node::nil = &_nil;
int isRightChild(node *r) {
return r->prev->ch[1] == r;
}
void rotate(node *r, int child) {
node *new_root = r->ch[child];
if (r->prev != node::nil) {
r->prev->ch[isRightChild(r)] = new_root;
}
new_root->prev = r->prev;
r->prev = new_root;
r->ch[child] = new_root->ch[child^1];
new_root->ch[child^1] = r;
}
void rotate(node *nd) {
node *pr = nd->prev;
int x = isRightChild(nd);
if (pr->prev != node::nil)
pr->prev->setCh(isRightChild(pr), nd);
nd->prev = pr->prev;
pr->setCh(x, nd->ch[1 ^ x]);
nd->setCh(1 ^ x, pr);
}
int _check_invariants(node *c) {
if (c == node::nil)
return 0;
int a, b;
if (((a = _check_invariants(c->ch[0])) == -1) || ((b = _check_invariants(c->ch[1])) == -1))
return -1;
if (a != b)
return -1;
if (c->red && (c->ch[0]->red || c->ch[1]->red))
return -1;
if (c->red)
return a;
else
return a + 1;
}
void rb_insert_fix(node *&root, node *z);
void insert(node *&r, int key) {
node *p = node::nil;
node *c = r;
while (c != node::nil) {
if (c->key == key) {
return;
} else {
p = c;
c = c->ch[c->key < key];
}
}
node *n = new node;
n->ch[0] = n->ch[1] = node::nil;
n->prev = p;
n->key = key;
n->red = true;
if (p == node::nil)
r = n;
else
p->ch[p->key < key] = n;
rb_insert_fix(r, n);
}
/*
bool check_invariants(node *root) {
return root->red == false && _check_invariants(root) != -1;
}
/*/
bool check_invariants(node *) {
return true;
}
//*/
void rb_insert_fix(node *&root, node *z) {
while (z->prev->red) {
bool dir = isRightChild(z->prev);
node *y = z->prev->prev->ch[dir^1];;
if (y->red) {
z->prev->red = false;
y->red = false;
z->prev->prev->red = true;
z = z->prev->prev;
} else {
if (isRightChild(z) != dir) {
node *nz = z->prev;
rotate(z);
z = nz;
}
z->prev->red = false;
z->prev->prev->red = true;
if (z->prev->prev == root)
root = z->prev;
rotate(z->prev);
}
}
root->red = false;
assert(check_invariants(root));
}
bool check(node *n, int key) {
if (n == node::nil)
return false;
if (n->key == key)
return true;
return check(n->ch[n->key < key], key);
}
void print_tree(node *x) {
if (x == node::nil)
return;
print_tree(x->ch[0]);
printf("%d ", x->key);
print_tree(x->ch[1]);
}
void del(node *nd) {
if (nd == node::nil)
return;
del(nd->ch[0]);
del(nd->ch[1]);
delete nd;
}
class tree {
node *root_ = node::nil;
public:
void insert(int key) {
::insert(root_, key);
}
bool check(int key) const {
return ::check(root_, key);
}
~tree() {
del(root_);
}
};
int main() {
tree t;
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
if (u) {
puts(t.check(v)? "Yes" : "No");
} else {
t.insert(v);
}
}
}
| C++ |
#include <bits/stdc++.h>
template <typename It, class Func>
It my_partition(It begin, It end, Func f) {
if (begin == end)
return begin;
It iter = begin;
for (It it = begin; it != end; ++it) {
if (f(*it)) {
std::iter_swap(iter, it);
++iter;
}
}
return iter;
}
template <typename It, class Compare =
std::less<typename std::iterator_traits<It>::value_type> >
void my_sort(It begin, It end, Compare comp = Compare()) {
typedef typename std::iterator_traits<It>::value_type T;
static std::minstd_rand eng;
auto n = std::distance(begin, end);
if (n <= 1)
return;
std::uniform_int_distribution<std::size_t> distr(0, n - 1);
auto x = *std::next(begin, distr(eng));
auto mid1 = my_partition(begin, end, [&x, comp] (const T &a) {
return comp(a, x);
});
auto mid2 = my_partition(mid1, end, [&x, comp] (const T &a) {
return !comp(x, a);
});
my_sort(begin, mid1, comp);
my_sort(mid2, end, comp);
}
template <typename T>
std::vector<T> read_array(std::istream &in=std::cin) {
int n;
in >> n;
std::vector<T> result(n);
for (int i = 0; i < n; ++i) {
std::cin >> result[i];
}
return result;
}
int main() {
auto a = read_array<int>();
my_sort(a.begin(), a.end());
std::copy(a.begin(), a.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << std::endl;
}
| C++ |
#include <bits/stdc++.h>
//* FOR C++ < 14
namespace std {
template <>
struct less<void> {
template <class A, class B>
auto operator()(const A &a, const B &b) -> decltype(a < b) {
return a < b;
}
};
}
//*/
template<class InputIt1, class InputIt2, class OutputIt,
class Compare = std::less<void>>
OutputIt my_merge(InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first, Compare comp = Compare()) {
while (first1 != last1 && first2 != last2) {
if (comp(*first1, *first2)) {
*(d_first++) = *(first1++);
} else {
*(d_first++) = *(first2++);
}
}
return std::copy(first2, last2, std::copy(first1, last1, d_first));
}
template<class InputIt1, class InputIt2, class OutputIt,
class Compare = std::less<void>>
OutputIt my_move_merge(InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first, Compare comp = Compare()) {
while (first1 != last1 && first2 != last2) {
if (comp(*first1, *first2)) {
*(d_first++) = std::move(*(first1++));
} else {
*(d_first++) = std::move(*(first2++));
}
}
return std::move(first2, last2, std::move(first1, last1, d_first));
}
template <typename It, class Compare=std::less<void>>
void my_sort(It begin, It end, Compare comp = Compare()) {
typedef typename std::iterator_traits<It>::value_type T;
auto n = std::distance(begin, end);
if (n <= 1)
return;
It med = std::next(begin, n / 2);
my_sort(begin, med, comp);
my_sort(med, end, comp);
std::vector<T> temporary(n);
my_move_merge(begin, med, med, end, temporary.begin(), comp);
std::move(temporary.begin(), temporary.end(), begin);
}
template <typename T>
std::vector<T> read_array(std::istream &in=std::cin) {
int n;
in >> n;
std::vector<T> result(n);
for (int i = 0; i < n; ++i) {
std::cin >> result[i];
}
return result;
}
int main() {
auto a = read_array<int>();
my_sort(a.begin(), a.end());
std::copy(a.begin(), a.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << std::endl;
}
| C++ |
#include <bits/stdc++.h>
template <typename It, class Compare =
std::less<typename std::iterator_traits<It>::value_type> >
It my_partition(It begin, It end,
const typename std::iterator_traits<It>::value_type &x,
Compare comp = Compare()) {
typedef typename std::iterator_traits<It>::value_type T;
if (begin == end)
return begin;
It left = begin, right = std::prev(end);
while (left != right) {
while (left != right && comp(*left, x))
++left;
while (left != right && !comp(*right, x))
--right;
if (left != right) {
std::iter_swap(left, right);
++left;
}
}
if (comp(*left, x))
return std::next(left);
else
return left;
}
template <typename It, class Compare =
std::less<typename std::iterator_traits<It>::value_type> >
void my_sort(It begin, It end, Compare comp = Compare()) {
typedef typename std::iterator_traits<It>::value_type T;
static std::minstd_rand eng;
auto n = std::distance(begin, end);
if (n <= 1)
return;
std::uniform_int_distribution<std::size_t> distr(0, n - 1);
auto x = *std::next(begin, distr(eng));
auto mid = my_partition(begin, end, x, comp);
//assert(std::all_of(begin, mid, [&](const T &y) { return comp(y, x); }));
//assert(std::all_of(mid, end, [&](const T &y) { return !comp(y, x); }));
if (mid == begin && *begin == x) {
my_sort(begin+1, end, comp);
return;
}
my_sort(begin, mid, comp);
my_sort(mid, end, comp);
}
template <typename T>
std::vector<T> read_array(std::istream &in=std::cin) {
int n;
in >> n;
std::vector<T> result(n);
for (int i = 0; i < n; ++i) {
std::cin >> result[i];
}
return result;
}
int main() {
auto a = read_array<int>();
int x;
std::cin >> x;
auto mid = my_partition(a.begin(), a.end(), x);
std::cout << std::distance(a.begin(), mid) << '\n'
<< std::distance(mid, a.end()) << '\n';
}
| C++ |
#include <bits/stdc++.h>
template <typename FwdIter,
class Comp = std::less<typename std::iterator_traits<FwdIter>
::value_type> >
void selectSort(FwdIter begin, FwdIter end, Comp cmp = Comp()) {
while (end != begin) {
auto it = std::max_element(begin, end, cmp);
std::iter_swap(it, --end);
}
}
int main() {
std::vector<int> a;
int n;
std::cin >> n;
std::copy_n(std::istream_iterator<int>(std::cin), n, std::back_inserter(a));
selectSort(a.begin(), a.end());
std::copy(a.begin(), a.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << std::endl;
}
| C++ |
#include <bits/stdc++.h>
template <typename FwdIter,
class Comp = std::less<typename std::iterator_traits<FwdIter>
::value_type>>
void swapMaximum(FwdIter begin, FwdIter end,
Comp cmp = Comp()){
std::iter_swap(max_element(begin, end, cmp), std::prev(end));
}
int main() {
std::vector<int> a;
int n;
std::cin >> n;
std::copy_n(std::istream_iterator<int>(std::cin), n, std::back_inserter(a));
if (!a.empty())
swapMaximum(a.begin(), a.end());
std::copy(a.begin(), a.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << std::endl;
};
| C++ |
#include <bits/stdc++.h>
namespace std { // I hate ancient compilers
template <>
struct less<void> {
template <class A, class B>
auto operator()(const A &a, const B &b) -> decltype(a < b) {
return a < b;
}
};
}
template<class InputIt1, class InputIt2, class OutputIt,
class Compare = std::less<void>>
OutputIt my_merge(InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
OutputIt d_first, Compare comp = Compare()) {
while (first1 != last1 && first2 != last2) {
if (comp(*first1, *first2)) {
*(d_first++) = *(first1++);
} else {
*(d_first++) = *(first2++);
}
}
return std::copy(first2, last2, std::copy(first1, last1, d_first));
}
template <typename T>
std::vector<T> read_array(std::istream &in=std::cin) {
int n;
in >> n;
std::vector<T> result(n);
for (int i = 0; i < n; ++i) {
std::cin >> result[i];
}
return result;
}
int main() {
std::vector<int> a(read_array<int>()), b(read_array<int>());
std::vector<int> c;
c.reserve(a.size() + b.size());
my_merge(a.begin(), a.end(), b.begin(), b.end(), std::back_inserter(c));
std::copy(c.begin(), c.end(), std::ostream_iterator<int>(std::cout, " "));
std::cout << std::endl;
}
| C++ |
#include <bits/stdc++.h>
class DSU {
mutable std::vector<int> dsu_;
std::vector<int> siz_;
public:
DSU(std::size_t size) : dsu_(size), siz_(size, 1) {
std::iota(dsu_.begin(), dsu_.end(), 0);
}
int root(int x) const {
int r = x;
while (dsu_[r] != r)
r = dsu_[r];
while (dsu_[x] != r) {
int y = dsu_[x];
dsu_[x] = r;
x = y;
}
return r;
}
void unite(int x, int y) {
using std::swap;
x = root(x);
y = root(y);
if (siz_[x] < siz_[y])
swap(x, y);
dsu_[y] = x;
siz_[x] += siz_[y];
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int n, m, k;
std::cin >> n >> m >> k;
DSU dsu(n);
std::vector<std::tuple<int, int, int> > ed;
for (int i = 0; i < 2 * m; ++i) {
int u, v, p;
std::cin >> u >> v >> p;
--u, --v;
if (u < v)
ed.emplace_back(p, u, v);
}
for (int i = 0; i + 1 < k; ++i) {
ed.emplace_back(0, i, i + 1);
}
std::sort(ed.begin(), ed.end());
int64_t cost = 0;
for (auto x : ed) {
int w, u, v;
std::tie(w, u, v) = x;
if (dsu.root(u) != dsu.root(v)) {
dsu.unite(u, v);
cost += w;
}
}
std::cout << cost << '\n';
}
| C++ |
#include <bits/stdc++.h>
class IncorrectGameStateException : public std::exception {
public:
const char *what() const noexcept override;
};
class IncorrectGameMoveException : public std::exception {
public:
const char *what() const noexcept override;
};
template <typename Result=int, class Iter>
auto countObjects(Iter begin, Iter end) {
std::unordered_map<typename std::iterator_traits<Iter>::value_type, Result>
result;
for (auto it = begin; it != end; ++it)
++result[*it];
return result;
}
class GameState {
std::vector<int> state_;
std::unordered_map<int, int> cnt_;
template <class Iter>
static inline std::vector<int> createVector_(Iter it, std::size_t n) {
std::vector<int> result(n);
std::copy_n(it, n, result.begin());
return result;
}
public:
GameState(std::vector<int> state, bool shouldBeUnique = true)
: state_(std::move(state)),
cnt_(countObjects(state_.begin(), state_.end())) {
if (std::unordered_set<int>(state_.begin(),
state_.end()).size() != state_.size()
&& shouldBeUnique)
throw IncorrectGameStateException();
}
template <class Iter>
GameState(Iter begin, Iter end, bool shouldBeUnique = true)
: GameState(std::vector<int>(begin, end), shouldBeUnique) {}
template <typename Iter>
GameState(Iter begin, std::size_t n, bool shouldBeUnique = true)
: GameState(createVector_(begin, n), shouldBeUnique) {}
GameState(const GameState &) = default;
GameState(GameState &&) noexcept = default;
GameState() = default;
GameState &operator = (const GameState &) = default;
GameState &operator = (GameState &&) noexcept = default;
template <class... Args>
void assign(Args &&... args) { // I'm too lazy to write 3 functions
*this = std::move(GameState(args...));
}
std::pair<std::size_t, std::size_t>
move(const std::vector<int> &move) const;
bool goodMove(const std::vector<int> &move) {
return state_ == move;
}
std::size_t size() const noexcept {
return state_.size();
}
};
const char *IncorrectGameStateException::what() const noexcept {
return "Game state is incorrect";
}
const char *IncorrectGameMoveException::what() const noexcept {
return "Game move is incorrect";
}
std::pair<std::size_t, std::size_t>
GameState::move(const std::vector<int> &move) const {
if (move.size() != state_.size())
throw IncorrectGameMoveException();
std::size_t bulls = 0, cows = 0;
auto cnt = cnt_;
for (size_t i = 0; i < state_.size(); ++i) {
if (move[i] == state_[i])
++bulls;
}
for (size_t i = 0; i < state_.size(); ++i) {
if (cnt[move[i]] != 0) {
--cnt[move[i]];
++cows;
}
}
return {bulls, cows};
}
GameState generateRandomState() {
auto seed = std::random_device()();
std::default_random_engine eng(seed);
std::vector<int> result;
for (int i = 0; i < 4; ++i) {
std::uniform_int_distribution<> dist(0, 9);
result.push_back(dist(eng));
}
return {result, false};
}
GameState readState() {
std::size_t n;
using std::cin;
using std::cout;
using std::endl;
cout << "Enter length of sequences: ";
cin >> n;
GameState state;;
for (;;) {
cout << "Enter sequence itself, separated by spaces: ";
try {
state.assign(std::istream_iterator<int>(std::cin), n);
break;
} catch (IncorrectGameStateException e) {
cout << "Incorrect sequence!" << endl;
}
}
return state;
}
// For testing only
int main() {
using std::cin;
using std::cout;
using std::endl;
GameState state = generateRandomState();
for (;;) {
cout << "Enter your move: ";
std::pair<std::size_t, std::size_t> moveResult;
try {
moveResult = state.move(std::istream_iterator<int>(std::cin));
} catch (IncorrectGameMoveException e) {
cout << "Incorrect move!" << endl;
continue;
}
if (moveResult.first == state.size()) {
break;
} else {
cout << moveResult.first << " : " << moveResult.second << endl;
}
}
cout << "You won! Game over." << endl;
}
| C++ |
#include<iostream>
#include<vector>
#include<algorithm>
using std::cin;
using std::cout;
using std::vector;
using std::min;
using std::pair;
using std::make_pair;
struct Point {
int x, y;
Point(int x, int y) : x(x), y(y) {
}
Point() : x(0), y(0) {
}
};
int distance(Point first, Point second) {
return (first.x - second.x) * (first.x - second.x)
+ (first.y - second.y) * (first.y - second.y);
}
void add_edge(vector<vector<int> > &graph, int v, int u) {
graph[v].push_back(u);
graph[u].push_back(v);
return;
}
void dfs(vector<vector<int> > &graph, vector<bool> &used, int n, int v) {
used[v] = true;
for (int to : graph[v]) {
if (!used[to]) {
dfs(graph, used, n, to);
}
}
}
int main() {
int n, k;
cin >> n >> k;
vector<vector<int> > graph(n);
vector<Point> points;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
points.push_back(Point(x, y));
}
for (int first = 0; first < n; ++first) {
for (int second = first + 1; second < n; ++second) {
if (distance(points[first], points[second]) <= k * k) {
add_edge(graph, first, second);
}
}
}
vector<bool> used;
used.assign(n, false);
dfs(graph, used, n, 0);
bool are_all_used = true;
for (int v = 0; v < n; ++v) {
if (!used[v]) {
are_all_used = false;
}
}
cout << (are_all_used ? "YES" : "NO");
return 0;
}
| C++ |
#ifndef GAME_STATE_H_INCLUDED
#define GAME_STATE_H_INCLUDED
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdlib>
#include<time.h>
using std::pair;
using std::make_pair;
using std::vector;
class GameState {
private:
int alphabet_sz;
int length;
vector<int> sequence;
int bulls;
int cows;
bool win;
public:
GameState(int sz, int len) :
alphabet_sz(sz), length(len), sequence(seq), bulls(0), cows(0), win(0) {
}
pair<int, int> answerForRequest(vector<int> &request) {
if (request.size() != length) {
throw "Lengths differ";
}
for (auto elem : request) {
if (elem > alphabet_sz) {
throw "Non-identified symbol";
}
}
for (int i = 0; i < request.size(); ++i) {
if (sequence[i] == request[i]) {
++bulls;
} else if (std::find(sequence.begin(), sequence.end(), request[i]) != sequence.end()) {
++cows;
}
}
if (bulls == len) {
win = true;
}
pair<int, int> answer_for_request = make_pair(bulls, cows);
bulls = 0;
cows = 0;
return answer_for_request;
}
bool state() {
return win;
}
};
#endif // GAME_STATE_H_INCLUDED
| C++ |
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#include<cstdlib>
#include<limits.h>
#include<time.h>
#include<iterator>
using std::cin;
using std::cout;
using std::vector;
using std::min;
using std::pair;
using std::make_pair;
using std::queue;
const vector<int> dx {1, 0, 0, -1};
const vector<int> dy {0, 1, -1, 0};
bool is_inside(int m, int n, int x, int y) {
return x >= 0 && x < m && y >= 0 && y < n;
}
void add_edge(vector<vector<int> > &graph, int v, int u) {
graph[v].push_back(u);
return;
}
int cg2int(int n, int i, int j) {
return n * i + j;
}
void bfs(vector<vector<int> > &graph, vector<int> &distance, int n, int m, int st) {
vector<int> used;
used.assign(n*m, 0);
used[st] = 1;
distance[st] = 0;
queue<int> q;
q.push(st);
while(!q.empty()) {
int v = q.front();
q.pop();
for (int to : graph[v]) {
if (!used[to]) {
used[to] = 1;
distance[to] = distance[v] + 1;
q.push(to);
}
}
}
return;
}
int main() {
srand(time(NULL));
int m, n;
cin >> m >> n;
int st_x, st_y, fn_x, fn_y;
cin >> st_x >> st_y;
cin >> fn_x >> fn_y;
vector<vector<int> > graph(n*m);
vector<vector<int> > is_clear(m);
for (int i = 0; i < m; ++i) {
is_clear[i].resize(n);
for (int j = 0; j < n; ++j) {
int is_filled = 0;
cin >> is_filled;
is_clear[i][j] = 1 - is_filled;
}
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
for (int index = 0; index < 4; ++index) {
int curr_i = i + dx[index], curr_j = j + dy[index];
if (is_inside(m, n, curr_i, curr_j)
&& is_clear[i][j] && is_clear[curr_i][curr_j]) {
add_edge(graph, cg2int(n, i, j), cg2int(n, curr_i, curr_j));
}
}
}
}
vector<int> distance;
distance.assign(n*m, -1);
bfs(graph, distance, n, m, cg2int(n, --st_x, --st_y));
int min_path = distance[cg2int(n, --fn_x, --fn_y)];
if (min_path == -1) {
cout << "NO\n";
return 0;
}
cout << min_path << "\n";
return 0;
}
| C++ |
#include<iostream>
#include<vector>
using std::pair;
using std::make_pair;
using std::vector;
using std::cin;
using std::cout;
const int white = 0;
const int grey = 1;
const int black = 2;
struct Graph {
vector<vector<int> > graph;
vector<int> color;
Graph(vector<vector<int> > &graph) : graph(graph), color(vector<int> ()) {
color.assign(graph.size(), white);
}
void remove_marks() {
color.assign(graph.size(), white);
}
};
class Visitor_bridges {
private:
vector<int> time_in;
vector<int> f_up;
int timer;
vector<pair<int, int> > bridges;
public:
Visitor_bridges(int vertexes) :
time_in(vector<int> (vertexes)),
f_up(vector<int> (vertexes)),
timer(0),
bridges(vector<pair<int, int> >) {
};
void start(Graph &graph, int v) {
graph.color[v] = grey;
time_in[v] = timer;
f_up[v] = timer;
++timer;
}
void enter_vertex(Graph &graph, int v, int to, int p) {
if (to != p && graph.color[to] == white) {
f_up[v] = std::min(f_up[v], time_in[to]);
}
}
bool condition(Graph &graph, int to, int p) {
return (to != p && graph.color[to] == white);
}
void leave_vertex(Graph &graph, int v, int to, int p) {
if (to != p && graph.color[to] == white) {
f_up[v] = std::min(f_up[v], f_up[to]);
if (f_up[to] > time_in[v]) {
bridges.push_back(make_pair(v, to));
}
}
}
void finish(Graph &graph, int v) {
graph.color[v] = black;
}
};
class Visitor_simple {
public:
Visitor_simple() {
};
void start(Graph &graph, int v) {
graph.color[v] = grey;
}
void enter_vertex(Graph &graph, int v, int to, int p) {
}
bool condition(Graph &graph, int to, int p) {
return graph.color[to] == white;
}
void leave_vertex(Graph &graph, int v, int to, int p) {
}
void finish(Graph &graph, int v) {
graph.color[v] = black;
}
};
template <typename Visitor>
void dfs(Graph &graph, int vertex, int parent, Visitor &visitor) {
visitor.start(graph, vertex);
for (int to : graph.graph[vertex]) {
visitor.enter_vertex(graph, vertex, to, parent);
if (visitor.condition(graph, to, parent)) {
dfs(graph, to, vertex, visitor);
}
visitor.leave_vertex(graph, vertex, to, parent);
}
visitor.finish(graph, vertex);
}
int main() {
int vertexes = 0;
int edges = 0;
cin >> vertexes >> edges;
vector<vector<int>> adjacent_list(vertexes);
for (int i = 0; i < edges; ++i) {
int from = 0, to = 0;
cin >> from >> to;
adjacent_list[--from].push_back(--to);
}
Graph graph(adjacent_list);
Visitor_bridges visitor(vertexes);
dfs(graph, 0, -1, visitor);
return 0;
}
| C++ |
#include<iostream>
#include<vector>
#include<algorithm>
using std::cin;
using std::cout;
using std::vector;
using std::min;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int> > path_cost(n);
for (int i = 0; i < n; ++i) {
path_cost[i].resize(m);
for (int j = 0; j < m; ++j) {
cin >> path_cost[i][j];
}
}
for (int i = 1; i < n; ++i) {
path_cost[i][0] += path_cost[i - 1][0];
}
for (int j = 1; j < m; ++j) {
path_cost[0][j] += path_cost[0][j - 1];
}
for (int i = 1; i < n; ++i) {
for (int j = 1; j < m; ++j) {
path_cost[i][j]
+= min(path_cost[i - 1][j], path_cost[i][j - 1]);
}
}
cout << path_cost[n - 1][m - 1] << "\n";
return 0;
}
| C++ |
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#include<cstdlib>
#include<limits.h>
#include<iterator>
#include<time.h>
using std::cin;
using std::cout;
using std::vector;
using std::pair;
using std::make_pair;
const int white = 0;
const int grey = 1;
const int black = 2;
typedef vector<vector<int> > Graph;
void addEdge(Graph &graph, int v, int u) {
graph[v].push_back(u);
return;
}
void dfs_cycle(Graph &graph, vector<int> &color, int v, bool &cycle) {
color[v] = grey;
for (int to : graph[v]) {
if (color[to] == grey) {
cycle = true;
return;
}
if (color[to] == white) {
dfs_cycle(graph, color, to, cycle);
}
}
color[v] = black;
return;
}
bool find_cycle(Graph &graph, int sz) {
vector<int> color;
color.assign(sz, white);
bool is_cycle = false;
for (int v = 0; v < sz; ++v) {
if (color[v] == white) {
dfs_cycle(graph, color, v, is_cycle);
}
}
return is_cycle;
}
void dfs_simple(Graph &graph, vector<bool> &used, int v, vector<int> &sorted) {
used[v] = true;
for (int to : graph[v]) {
if (!used[to])
dfs_simple(graph, used, to, sorted);
}
sorted.push_back(v);
return;
}
void topological_sort(Graph &graph, int sz, vector<int> &sorted) {
vector<bool> used;
used.assign(sz, false);
for (int v = 0; v < sz; ++v) {
if (!used[v] && graph[v].size() != 0) {
dfs_simple(graph, used, v, sorted);
}
}
std::reverse(sorted.begin(), sorted.end());
return;
}
bool is_start(int n, int sz) {
return n < sz / 2;
}
void build_segments(vector<int> &order, int sz, vector<pair<int, int> > &segments) {
int x = 0;
for (int v : order) {
if (is_start(v, sz)) {
segments[v].first = x;
} else {
segments[v - sz / 2].second = x;
}
++x;
}
return;
}
int main() {
int n, a, b;
cin >> n >> a >> b;
Graph order(2 * n);
for (int i = 0; i < n; ++i) {
addEdge(order, i, i + n);
}
int first_segment = 0, second_segment = 0;
for (int i = 0; i < a; ++i) {
cin >> first_segment >> second_segment;
--first_segment, --second_segment;
int first_segment_finish = first_segment + n;
int second_segment_start = second_segment;
addEdge(order, first_segment_finish, second_segment_start);
}
for (int i = 0; i < b; ++i) {
cin >> first_segment >> second_segment;
--first_segment, --second_segment;
int first_segment_start = first_segment;
int first_segment_finish = first_segment + n;
int second_segment_start = second_segment;
int second_segment_finish = second_segment + n;
addEdge(order, first_segment_start, second_segment_finish);
addEdge(order, second_segment_start, first_segment_finish);
}
if (find_cycle(order, 2 * n)) {
cout << "Impossible\n";
return 0;
}
vector<int> sorted;
topological_sort(order, 2 * n, sorted);
vector<pair<int, int> > segments;
segments.assign(n, make_pair(-1, -1));
build_segments(sorted, 2 * n, segments);
for (int i = 0; i < n; ++i) {
cout << segments[i].first << " " << segments[i].second << "\n";
}
return 0;
}
| C++ |
#include<iostream>
#include<vector>
#include<algorithm>
using std::cin;
using std::cout;
using std::vector;
using std::min;
const int MAGIC_CONST = 268435459;
int main() {
int n, m;
cin >> n >> m;
vector<vector<bool> > is_clear(n);
vector<vector<int> > path_number(n);
for (int i = 0; i < n; ++i) {
is_clear[i].resize(m);
path_number[i].resize(m);
for (int j = 0; j < m; ++j) {
int is_cage_clear;
cin >> is_cage_clear;
is_clear[i][j] = is_cage_clear;
path_number[i][j] = 0;
}
}
if (!is_clear[0][0] || !is_clear[n - 1][m - 1]) {
cout << 0;
return 0;
}
path_number[0][0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (i != 0 && is_clear[i - 1][j]) {
path_number[i][j] = (path_number[i][j] + path_number[i - 1][j]) % MAGIC_CONST;
}
if (j != 0 && is_clear[i][j - 1]) {
path_number[i][j] = (path_number[i][j] + path_number[i][j - 1]) % MAGIC_CONST;
}
}
}
cout << (path_number[n - 1][m - 1]) % MAGIC_CONST << "\n";
return 0;
}
| C++ |
#include <iostream>
#include <algorithm>
struct Interval {
double left, right, cost;
Interval (double left, double right, double cost)
:left(left), right(right), cost(cost) {
}
Interval () {
}
};
void readInput (std::vector<Interval> &input_data, int amount) {
for (int iteration = 0; iteration < amount; ++iteration) {
Interval current_interval;
std::cin >> current_interval.left >> current_interval.right >>
current_interval.cost;
input_data.push_back(current_interval);
}
}
bool intervalComparison (Interval first, Interval second) {
if (first.right < second.right || (first.right == second.right &&
first.left < second.left)) {
return true;
}
return false;
}
bool prevAllowedComparsion(double value, Interval element) {
if (element.right > value) {
return true;
}
return false;
}
double countMaxCost (std::vector<Interval> &data) {
int prev_allowed[data.size()];
std::vector< std::pair<double, int> > max_if_picked(data.size());
// counting previos interval that we can take
prev_allowed[0] = -1;
for (int current = 1; current < data.size(); ++current) {
prev_allowed[current] = std::upper_bound(data.begin(),
data.begin() + current, data[current].left,
prevAllowedComparsion) - data.begin() - 1;
}
// counting max_cost if we take this interval
max_if_picked[0].first = data[0].cost;
max_if_picked[0].second = -1;
for (int current = 1; current < data.size(); ++current) {
int max_from_prev = current - 1;
if (current == 1) {
max_from_prev = 0;
max_if_picked[1].second = 0;
if (prev_allowed[1] == 0) {
max_if_picked[1].first = data[0].cost + data[1].cost;
} else {
max_if_picked[1].first = data[1].cost;
}
continue;
}
if (max_if_picked[current - 1].first <
max_if_picked[max_if_picked[current - 1].second].first) {
max_from_prev = max_if_picked[current - 1].second;
}
while (max_from_prev != -1 && max_from_prev > prev_allowed[current]) {
max_from_prev = max_if_picked[max_from_prev].second;
}
if (max_from_prev == -1) {
max_if_picked[current].first = data[current].cost;
} else {
max_if_picked[current].first = data[current].cost +
max_if_picked[max_from_prev].first;
}
if (max_if_picked[current - 1].first >
max_if_picked[max_if_picked[current - 1].second].first) {
max_if_picked[current].second = current - 1;
} else {
max_if_picked[current].second = max_if_picked[current - 1].second;
}
}
// counting answer
double answer = -1;
for (int iteration = 0; iteration < data.size(); ++iteration) {
answer = std::max(answer, max_if_picked[iteration].first);
}
/*for (int i = 0; i < data.size(); ++i) {
std::cout << i << " " << prev_allowed[i] << " " << max_if_picked[i].first << "\n";
} */
return answer;
}
void printAnswer (double answer) {
std::cout << answer;
}
int main () {
int amount;
std::cin >> amount;
if (amount == 0) {
std::cout << 0;
return 0;
}
std::vector<Interval> data;
readInput (data, amount);
std::sort(data.begin(), data.end(), intervalComparison);
double answer = countMaxCost (data);
printAnswer (answer);
return 0;
}
| C++ |
#include <iostream>
#include <vector>
void ReadInput (std::vector <int> &elements, int array_size) {
for (int iteration = 0; iteration < array_size; ++iteration) {
int element;
std::cin >> element;
elements.push_back(element);
}
}
template <typename iterator_type>
void MaxInTheEnd (iterator_type begin, iterator_type end) {
iterator_type max_element = begin;
while (begin != end) {
if (*max_element < *begin) {
max_element = begin;
}
++begin;
}
std::swap(*max_element, *(end - 1));
}
void PrintAnswer (std::vector <int> &answer) {
for (auto element : answer) {
std::cout << element << " ";
}
}
int main() {
int array_size;
std::cin >> array_size;
if (array_size == 0) {
return 0;
}
std::vector <int> elements;
ReadInput (elements, array_size);
MaxInTheEnd (elements.begin(), elements.end());
PrintAnswer (elements);
}
| C++ |
#include <iostream>
#include <vector>
void ReadInput (std::vector <int> &elements, int array_size) {
for (int iteration = 0; iteration < array_size; ++iteration) {
int element;
std::cin >> element;
elements.push_back(element);
}
}
template <typename iterator_type, typename data_type>
iterator_type Partition (iterator_type begin, iterator_type end, data_type element) {
iterator_type output_iterator = begin;
int count = 0;
while (begin != end) {
if (*begin < element) {
++count;
}
++begin;
}
for (int iteration = 0; iteration < count; ++iteration) {
++output_iterator;
}
return output_iterator;
}
template <typename output_type>
void PrintAnswer (output_type answer) {
std::cout << answer << "\n";
}
int main() {
int array_size;
std::cin >> array_size;
if (array_size == 0) {
std::cout << "0\n0";
return 0;
}
std::vector <int> elements;
ReadInput (elements, array_size);
int partition_element;
std::cin >> partition_element;
auto partition_point = Partition (elements.begin(), elements.end(), partition_element);
int answer = partition_point - elements.begin();
PrintAnswer (answer);
PrintAnswer (elements.size() - answer);
return 0;
} | C++ |
#include <iostream>
#include <vector>
void ReadInput (std::vector <int> &elements, int array_size) {
for (int iteration = 0; iteration < array_size; ++iteration) {
int element;
std::cin >> element;
elements.push_back(element);
}
}
void PrintAnswer (std::vector <int> &answer) {
for (auto element : answer) {
std::cout << element << " ";
}
}
template <typename iterator_type>
void Merge (iterator_type first_begin, iterator_type first_end,
iterator_type second_begin, iterator_type second_end,
std::vector <int> &output_vector) {
while (first_begin != first_end || second_begin != second_end) {
if (first_begin == first_end) {
output_vector.push_back (*second_begin);
++second_begin;
} else if (second_begin == second_end) {
output_vector.push_back (*first_begin);
++first_begin;
} else {
if (*first_begin < *second_begin) {
output_vector.push_back (*first_begin);
++first_begin;
} else {
output_vector.push_back (*second_begin);
++second_begin;
}
}
}
}
std::vector <int> Sort (std::vector <int> elements) {
if (elements.size() <= 1) {
return elements;
}
std::vector <int> left_half, right_half;
for (int element_number = 0; element_number < elements.size();
++element_number) {
if (element_number < elements.size() / 2) {
left_half.push_back (elements[element_number]);
} else {
right_half.push_back (elements[element_number]);
}
}
std::vector <int> output_vector;
left_half = Sort (left_half);
right_half = Sort (right_half);
Merge (left_half.begin(), left_half.end(),
right_half.begin(), right_half.end(), output_vector);
return output_vector;
}
int main() {
int array_size;
std::cin >> array_size;
if (array_size == 0) {
return 0;
}
std::vector <int> elements;
ReadInput (elements, array_size);
elements = Sort (elements);
PrintAnswer (elements);
}
| C++ |
#include <iostream>
#include <vector>
void ReadInput (std::vector <int> &elements, int array_size) {
for (int iteration = 0; iteration < array_size; ++iteration) {
int element;
std::cin >> element;
elements.push_back(element);
}
}
void PrintAnswer (std::vector <int> &answer) {
for (auto element : answer) {
std::cout << element << " ";
}
}
template <typename iterator_type>
void Merge (iterator_type first_begin, iterator_type first_end,
iterator_type second_begin, iterator_type second_end,
std::vector <int> &output_vector) {
while (first_begin != first_end || second_begin != second_end) {
if (first_begin == first_end) {
output_vector.push_back (*second_begin);
++second_begin;
} else if (second_begin == second_end) {
output_vector.push_back (*first_begin);
++first_begin;
} else {
if (*first_begin < *second_begin) {
output_vector.push_back (*first_begin);
++first_begin;
} else {
output_vector.push_back (*second_begin);
++second_begin;
}
}
}
}
int main() {
int first_array_size;
std::cin >> first_array_size;
std::vector <int> first_array;
ReadInput (first_array, first_array_size);
int second_array_size;
std::cin >> second_array_size;
std::vector <int> second_array;
ReadInput (second_array, second_array_size);
std::vector <int> answer;
Merge (first_array.begin(), first_array.end(),
second_array.begin(), second_array.end(), answer);
PrintAnswer (answer);
}
| C++ |
#include <iostream>
#include <vector>
void ReadInput (std::vector <int> &elements, int array_size) {
for (int iteration = 0; iteration < array_size; ++iteration) {
int element;
std::cin >> element;
elements.push_back(element);
}
}
template <typename iterator_type>
void MaxInTheEnd (iterator_type begin, iterator_type end) {
iterator_type max_element = begin;
while (begin != end) {
if (*max_element < *begin) {
max_element = begin;
}
++begin;
}
std::swap(*max_element, *(end - 1));
}
void PrintAnswer (std::vector <int> &answer) {
for (auto element : answer) {
std::cout << element << " ";
}
}
int main() {
int array_size;
std::cin >> array_size;
if (array_size == 0) {
return 0;
}
std::vector <int> elements;
ReadInput (elements, array_size);
while (array_size != 1) {
MaxInTheEnd (elements.begin(), elements.begin() + (array_size--));
}
PrintAnswer (elements);
}
| C++ |
#include <iostream>
#include <vector>
#include <cstdlib>
void ReadInput (int *elements, int array_size) {
for (int iteration = 0; iteration < array_size; ++iteration) {
int element;
std::cin >> element;
*(elements + iteration) = element;
}
}
template <typename iterator_type, typename data_type>
std::pair<iterator_type, iterator_type> Partition (iterator_type begin, iterator_type end, data_type element) {
iterator_type begin_copy = begin, end_copy = end;
--end;
// whole array partition
while (begin != end) {
while (*begin < element) {
++begin;
}
while (*end > element) {
if (begin == end) {
break;
}
--end;
}
if (begin < end) {
std::swap(*begin, *end);
begin++;
}
}
// first part partition with (element - 1)
while (begin_copy != begin) {
while (*begin_copy < element - 1) {
++begin_copy;
}
while (*begin > element - 1) {
if (begin_copy == begin) {
break;
}
--begin;
}
if (begin_copy < begin) {
std::swap(*begin_copy, *begin);
begin_copy++;
}
}
return std::make_pair(begin_copy, end);
}
template <typename iterator_type>
void Sort (iterator_type begin, iterator_type end) {
if (end - begin <= 1) {
return;
}
if (end - begin == 2) {
if (*begin > *(begin + 1)) {
std::swap(*begin, *(begin + 1));
}
return;
}
std::pair<iterator_type, iterator_type> borders;
borders = Partition (begin, end, *(begin + (rand() % (end - begin))));
Sort (begin, borders.first);
Sort (borders.second, end);
}
void PrintAnswer (int *answer, int array_size) {
for (int element_index = 0; element_index < array_size; ++element_index) {
std::cout << *(answer + element_index) << " ";
}
}
int main() {
int array_size;
std::cin >> array_size;
if (array_size == 0) {
return 0;
}
int elements[array_size];
ReadInput (elements, array_size);
Sort (elements, elements + array_size);
PrintAnswer (elements, array_size);
return 0;
} | C++ |
#include <iostream>
#include <vector>
class Dfs {
public:
std::vector<std::vector<int> > *graph;
std::vector <bool> used;
Dfs (std::vector<std::vector<int> > *graph):graph(graph) {
for (int i = 0; i < graph->size(); ++i) {
used.push_back(false);
}
};
virtual void dfsVisitCurrent (int current, int prev = -1) {
return;
}
virtual void dfsVisitNext (int current, int next) {
return;
}
virtual void dfsWas (int current, int next) {
return;
}
void dfs (int current, int prev = -1) {
used[current] = true;
dfsVisitCurrent (current, prev);
for (auto next_it = 0; next_it < graph->at(current).size(); ++next_it) {
int next = (graph->at(current))[next_it];
if (next == prev) {
continue;
} else if (used[next]) {
dfsWas(current, next);
} else {
dfs(next, current);
dfsVisitNext(current, next);
}
}
}
};
class VertexCout : public Dfs {
public:
VertexCout (std::vector<std::vector<int> > *graph):Dfs(graph) {
};
void dfsVisitCurrent (int current, int prev = -1) {
std::cout << "entering " << current << " from " << prev << '\n';
}
void dfsVisitNext (int current, int next) {
std::cout << "made Dfs with current: " << current << ", next: " << next << '\n';
}
void dfsWas (int current, int next) {
return;
}
};
class CountBridges : public Dfs {
public:
int timer, answer;
std::vector<int> time_in, time_back;
CountBridges (std::vector<std::vector<int> > *graph):Dfs(graph) {
timer = 0;
answer = 0;
for (int i = 0; i < graph->size(); ++i) {
time_in.push_back(0);
time_back.push_back(0);
}
};
void dfsVisitCurrent (int current, int prev = -1) {
std::cout << "entering " << current << " from " << prev << '\n';
time_in[current] = timer;
time_back[current] = timer++;
}
void dfsVisitNext (int current, int next) {
time_back[current] = std::min(time_back[current], time_back[next]);
if (time_in[current] < time_back[next]) {
answer += 1;
}
}
void dfsWas (int current, int next) {
time_back[current] = std::min(time_in[next], time_back[current]);
}
};
int main () {
int n, m;
std::cin >> n >> m;
std::vector<std::vector<int> > graph(n);
for (int i = 0; i < m; ++i) {
int x, y;
std::cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
CountBridges* pointer = new CountBridges (&graph);
pointer->dfs(0);
std::cout << pointer->answer;
return 0;
}
| C++ |
int main()
{
}
| C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using std::cin;
using std::cout;
using std::vector;
template<typename Iter, typename Comp>
Iter Max_to_end(Iter begin, Iter end, Comp cmp) {
if (begin == end) {
return end;
}
Iter max_position = std::max_element(begin, end, cmp);
--end;
std::swap(*max_position, *end);
return end;
}
template<typename T>
void Input(std::istream &input, vector<T> &sequence) {
size_t size;
input >> size;
sequence.resize(size);
for (size_t index = 0; index < size; ++index) {
input >> sequence[index];
}
}
template<typename T>
void Output(std::ostream &output, vector<T> &sequence) {
for (size_t index = 0; index < sequence.size(); ++index) {
output << sequence[index] << " ";
}
}
int main() {
vector<int> sequence;
Input(cin, sequence);
Max_to_end(sequence.begin(), sequence.end(), std::less<int>());
Output(cout, sequence);
}
| C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <cassert>
using std::cin;
using std::cout;
using std::vector;
template<typename Iter, typename Comp>
Iter Partition(Iter begin, Iter end, typename std::iterator_traits<Iter>::value_type elem, Comp cmp) {
if (begin == end) {
return end;
}
--end;
while (begin != end) {
while (begin != end && cmp(*begin, elem)) {
++begin;
}
while (begin != end && !cmp(*end, elem)) {
--end;
}
if (begin != end) {
std::swap(*begin, *end);
}
}
if (cmp(*end, elem)) {
++end;
}
return end;
}
template<typename T>
void Input(std::istream &input, vector<T> &sequence, T &elem) {
size_t size;
input >> size;
sequence.resize(size);
for (size_t index = 0; index < size; ++index) {
input >> sequence[index];
}
input >> elem;
}
template<typename T>
void Output(std::ostream &output, T first, T second) {
output << first << "\n" << second;
}
int main() {
vector<int> sequence;
int elem;
Input(cin, sequence, elem);
auto separate = Partition(sequence.begin(), sequence.end(), elem, std::less<int>());
Output(cout, separate - sequence.begin(), sequence.end() - separate);
}
| C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <cassert>
using std::cin;
using std::cout;
using std::vector;
template<typename Iter, typename Comp>
Iter Merge(Iter begin1, Iter end1, Iter begin2, Iter end2, Iter out, Comp cmp) {
while (begin1 != end1 && begin2 != end2) {
if (cmp(*begin1, *begin2)) {
*out = *begin1;
++begin1;
++out;
}
else {
*out = *begin2;
++begin2;
++out;
}
}
if (begin2 == end2) {
while (begin1 != end1) {
*out = *begin1;
++begin1;
++out;
}
}
else {
while (begin2 != end2) {
*out = *begin2;
++begin2;
++out;
}
}
return out;
}
template<typename Iter, typename Comp>
void Sort(Iter begin, Iter end, Comp cmp) {
size_t size = std::distance(begin, end);
if (size <= 1) {
return;
}
Iter middle = begin;
std::advance(middle, size / 2);
Sort(begin, middle, cmp);
Sort(middle, end, cmp);
vector<typename std::iterator_traits<Iter>::value_type> for_merge(size);
Merge(begin, middle, middle, end, for_merge.begin(), cmp);
std::copy(for_merge.begin(), for_merge.end(), begin);
}
template<typename T>
void Input(std::istream &input, vector<T> &sequence) {
size_t size;
input >> size;
sequence.resize(size);
for (size_t index = 0; index < size; ++index) {
input >> sequence[index];
}
}
template<typename T>
void Output(std::ostream &output, vector<T> &sequence) {
for (size_t index = 0; index < sequence.size(); ++index) {
output << sequence[index] << " ";
}
}
int main() {
vector<int> sequence;
Input(cin, sequence);
Sort(sequence.begin(), sequence.end(), std::less<int>());
Output(cout, sequence);
}
| C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using std::cin;
using std::cout;
using std::vector;
template<typename Iter, typename Comp>
Iter Merge(Iter begin1, Iter end1, Iter begin2, Iter end2, Iter out, Comp cmp) {
while (begin1 != end1 && begin2 != end2) {
if (cmp(*begin1, *begin2)) {
*out = *begin1;
++begin1;
++out;
}
else {
*out = *begin2;
++begin2;
++out;
}
}
if (begin2 == end2) {
while (begin1 != end1) {
*out = *begin1;
++begin1;
++out;
}
}
else {
while (begin2 != end2) {
*out = *begin2;
++begin2;
++out;
}
}
return out;
}
template<typename T>
void Input(std::istream &input, vector<T> &sequence) {
size_t size;
input >> size;
sequence.resize(size);
for (size_t index = 0; index < size; ++index) {
input >> sequence[index];
}
}
template<typename T>
void Output(std::ostream &output, vector<T> &sequence) {
for (size_t index = 0; index < sequence.size(); ++index) {
output << sequence[index] << " ";
}
}
int main() {
vector<int> sequence1, sequence2;
Input(cin, sequence1);
Input(cin, sequence2);
vector<int> result(sequence1.size() + sequence2.size());
Merge(sequence1.begin(), sequence1.end(), sequence2.begin(), sequence2.end(), result.begin(), std::less<int>());
Output(cout, result);
}
| C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using std::cin;
using std::cout;
using std::vector;
template<typename Iter, typename Comp>
Iter Max_to_end(Iter begin, Iter end, Comp cmp) {
if (begin == end) {
return end;
}
Iter max_position = std::max_element(begin, end, cmp);
--end;
std::swap(*max_position, *end);
return end;
}
template<typename Iter, typename Comp>
void Sort(Iter begin, Iter end, Comp cmp) {
while (begin != end) {
end = Max_to_end(begin, end, cmp);
}
}
template<typename T>
void Input(std::istream &input, vector<T> &sequence) {
size_t size;
input >> size;
sequence.resize(size);
for (size_t index = 0; index < size; ++index) {
input >> sequence[index];
}
}
template<typename T>
void Output(std::ostream &output, vector<T> &sequence) {
for (size_t index = 0; index < sequence.size(); ++index) {
output << sequence[index] << " ";
}
}
int main() {
vector<int> sequence;
Input(cin, sequence);
Sort(sequence.begin(), sequence.end(), std::less<int>());
Output(cout, sequence);
}
| C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <cassert>
#include <cstdlib>
#include <utility>
using std::cin;
using std::cout;
using std::vector;
template<typename Iter, typename Comp>
Iter Partition(Iter begin, Iter end, typename std::iterator_traits<Iter>::value_type elem, Comp cmp) {
if (begin == end) {
return end;
}
--end;
do {
while (begin != end && cmp(*begin, elem)) {
++begin;
}
while (begin != end && cmp(elem, *end)) {
--end;
}
if (begin != end) {
std::swap(*begin, *end);
++begin;
}
} while (begin != end);
return end;
}
template<typename Iter, typename Comp>
void Sort(Iter begin, Iter end, Comp cmp){
size_t size = std::distance(begin, end);
if (size <= 1) {
return;
}
auto sep = *std::next(begin, rand() % size);
Iter middle = Partition(begin, end, sep, cmp);
Iter left_middle = middle;
while (left_middle != begin && *left_middle == *middle) {
--left_middle;
}
++left_middle;
Sort(begin, left_middle, cmp);
Sort(middle, end, cmp);
}
template<typename T>
void Input(std::istream &input, vector<T> &sequence) {
size_t size;
input >> size;
sequence.resize(size);
for (size_t index = 0; index < size; ++index) {
input >> sequence[index];
}
srand(218);
}
template<typename T>
void Output(std::ostream &output, vector<T> &sequence) {
for (size_t index = 0; index < sequence.size(); ++index) {
output << sequence[index] << " ";
}
}
int main() {
vector<int> sequence;
Input(cin, sequence);
Sort(sequence.begin(), sequence.end(), std::less<int>());
Output(cout, sequence);
}
| C++ |
#include <iostream>
#include <vector>
#include <utility>
using std::cin;
using std::cout;
using std::endl;
using std::vector;
using std::pair;
using std::make_pair;
void Input(vector<vector<int> > *matrix) {
size_t n;
cin >> n;
matrix->resize(n, vector<int>(n));
for (size_t i = 0; i < n; ++i) {
for (size_t j = 0; j < n; ++j) {
cin >> matrix->operator[](i)[j];
}
}
}
template <typename T>
bool In_matrix(vector<vector<T> > *matrix,
pair<size_t, size_t> pos) {
return (0 <= pos.first && pos.first < matrix->size() &&
0 <= pos.second && pos.second < matrix->size());
}
template <typename T>
T Matrix_value(vector<vector<T> > *matrix,
pair<size_t, size_t> pos) {
return matrix->operator[](pos.first)[pos.second];
}
template <typename T, typename Comp>
pair<size_t, size_t> Check_extr(vector<vector<T> > *matrix,
pair<size_t, size_t> pos_min,
Comp cmp) {
vector<pair<int, int>> step = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
pair<size_t, size_t> check;
for (auto &step_kind: step) {
check = pos_min;
check.first += step_kind.first;
check.second += step_kind.second;
if (In_matrix(matrix, check) && cmp(Matrix_value(matrix, check),
Matrix_value(matrix, pos_min))) {
return check;
}
}
return pos_min;
}
bool In_quater(pair<size_t, size_t> left_down,
pair<size_t, size_t> right_up,
pair<size_t, size_t> pos) {
return (left_down.first <= pos.first && pos.first <= right_up.first &&
left_down.second <= pos.second && pos.second <= right_up.second);
}
template <typename T, typename Comp>
pair<size_t, size_t> Extremum(vector<vector<T> > *matrix,
pair<size_t, size_t> left_down,
pair<size_t, size_t> right_up,
Comp cmp) {
if (left_down == right_up) {
return left_down;
}
vector<vector<T> > &m = *matrix;
pair<size_t, size_t> center = make_pair((left_down.first + right_up.first) / 2,
(left_down.second + right_up.second) / 2);
pair<size_t, size_t> pos_min = center;
for (size_t i = left_down.first; i <= right_up.first; ++i) {
if (cmp(m[i][center.second], Matrix_value(matrix, pos_min))) {
pos_min = make_pair(i, center.second);
}
}
for (size_t j = left_down.second; j <= right_up.second; ++j) {
if (cmp(m[center.first][j], Matrix_value(matrix, pos_min))) {
pos_min = make_pair(center.first, j);
}
}
pair<size_t, size_t> go_quater = Check_extr(matrix, pos_min, cmp);
if (go_quater == pos_min) {
return pos_min;
}
pair<size_t, size_t> left_down_q, right_up_q;
left_down_q = left_down;
right_up_q = center;
if (In_quater(left_down_q, right_up_q, go_quater)) {
return Extremum(matrix, left_down_q, right_up_q, cmp);
}
left_down_q = center;
right_up_q = right_up;
if (In_quater(left_down_q, right_up_q, go_quater)) {
return Extremum(matrix, left_down_q, right_up_q, cmp);
}
left_down_q = make_pair(left_down.first, center.second);
right_up_q = make_pair(center.first, right_up.second);
if (In_quater(left_down_q, right_up_q, go_quater)) {
return Extremum(matrix, left_down_q, right_up_q, cmp);
}
left_down_q = make_pair(center.first, left_down.second);
right_up_q = make_pair(right_up.first, center.second);
if (In_quater(left_down_q, right_up_q, go_quater)) {
return Extremum(matrix, left_down_q, right_up_q, cmp);
}
}
void Output(pair<size_t, size_t> answer) {
cout << answer.first + 1 << " " << answer.second + 1 << endl;
}
int main() {
vector<vector<int> > matrix;
Input(&matrix);
size_t n = matrix.size();
--n;
pair<size_t, size_t> answer = Extremum(&matrix, make_pair(0, 0), make_pair(n, n), std::less<int>());
Output(answer);
}
| C++ |
#include<iostream>
#include<vector>
#include<algorithm>
using std::vector;
using std::pair;
using std::make_pair;
using std::swap;
using std::cin;
using std::cout;
using std::iter_swap;
template<typename T>
pair<T, T> Partition(T left, T right, int mid) {
while (left <= right) {
while (*left < mid)
++left;
while (*right > mid)
--right;
if (left <= right) {
iter_swap(left, right);
++left;
--right;
}
}
auto res = make_pair(left, right);
return res;
}
template<typename T>
void QuickSort(vector<T> &v, int left, int right) {
if (left >= right) {
return;
}
int mid = v[left + (std::rand() % (right - left))];
pair<vector<int>::iterator, vector<int>::iterator>
help = Partition(v.begin() + left, v.begin() + right, mid);
auto less = distance(v.begin() + left, help.second);
auto larger_or_equal = distance(v.begin() + left, help.first);
QuickSort(v, left, left + less);
QuickSort(v, left + larger_or_equal, right);
}
template<typename T>
void Input(vector<T> &v) {
size_t n;
cin >> n;
v.resize(n);
for (size_t i = 0; i < n; ++i) {
cin >> v[i];
}
}
template<typename T>
void Output(vector<T> &v) {
for (auto elem : v) {
cout << elem << " ";
}
}
int main() {
vector<int> v;
Input(v);
QuickSort(v, 0, v.size() - 1);
Output(v);
}
| C++ |
#include<iostream>
#include<algorithm>
#include<vector>
using std::vector;
using std::pair;
using std::make_pair;
using std::swap;
using std::cin;
using std::cout;
template<typename T>
void Input(vector<T> &v, vector<T> &help) {
size_t size;
cin >> size;
v.resize(size);
help.resize(size);
for (size_t i = 0; i < size; ++i) {
cin >> v[i];
}
}
template<typename T>
void Split(pair <T, T> input1, pair<T, T> input2, T res)
{
while (input1.first != input1.second && input2.first != input2.second) {
if (*input1.first < *input2.first) {
*res = *input1.first;
++res;
++input1.first;
}
else {
*res = *input2.first;
++res;
++input2.first;
}
}
while (input1.first != input1.second) {
*res = *input1.first;
++res;
++input1.first;
}
while (input2.first != input2.second) {
*res = *input2.first;
++res;
++input2.first;
}
}
template<typename T>
void Merge(vector<T> &start, int l, int r, vector<T> &help) {
if (r <= l) {
return;
}
Merge(start, l, (l + r) / 2, help);
Merge(start, (l + r) / 2 + 1, r, help);
auto first = make_pair(start.begin() + l, start.begin() + (l + r) / 2 + 1);
auto second = make_pair(start.begin() + (l + r) / 2 + 1, start.begin() + r + 1);
Split(first, second, help.begin() + l);
for (int i = l; i <= r; ++i)
start[i] = help[i];
}
template<typename T>
void Output(const vector<T> &v) {
for (auto elem : v) {
cout << elem << " ";
}
}
int main() {
vector<int> v, help;
Input(v, help);
Merge(v, 0, v.size() - 1, help);
Output(v);
} | C++ |
#include<iostream>
#include<algorithm>
#include<vector>
using std::vector;
using std::pair;
using std::make_pair;
using std::swap;
using std::cin;
using std::cout;
template<typename T>
void Input(vector<T> &first, vector<T> &second, vector<T> &res) {
int size_first;
cin >> size_first;
first.resize(size_first);
for (int i = 0; i < size_first; ++i) {
cin >> first[i];
}
int size_second;
cin >> size_second;
second.resize(size_second);
for (int i = 0; i < size_second; ++i) {
cin >> second[i];
}
res.resize(size_first + size_second);
}
template<typename T>
void Split(pair <T, T> input1, pair<T, T> input2, T res)
{
while (input1.first != input1.second && input2.first != input2.second) {
if (*input1.first < *input2.first) {
*res = *input1.first;
++res;
++input1.first;
}
else {
*res = *input2.first;
++res;
++input2.first;
}
}
while (input1.first != input1.second) {
*res = *input1.first;
++res;
++input1.first;
}
while (input2.first != input2.second) {
*res = *input2.first;
++res;
++input2.first;
}
}
template<typename T>
void Output(const vector<T> &v) {
for (auto elem : v) {
cout << elem << " ";
}
}
int main() {
vector<int> first, second, res;
Input(first, second, res);
auto first_iterator = make_pair(first.begin(), first.end());
auto second_iterator = make_pair(second.begin(), second.end());
Split(first_iterator, second_iterator, res.begin());
Output(res);
} | C++ |
#include<iostream>
#include<algorithm>
#include<vector>
using std::vector;
using std::cin;
using std::cout;
using std::iter_swap;
template<typename T>
void Input(vector<T> &v) {
size_t size;
cin >> size;
v.resize(size);
for (size_t i = 0; i < size; ++i) {
cin >> v[i];
}
}
template<typename T>
void SwapMax(vector<T> &v) {
if (!v.size()) {
return;
}
iter_swap(max_element(v.begin(), v.end()), (v.end() - 1));
}
template<typename T>
void Output(const vector<T> &v) {
for (auto elem : v) {
cout << elem << " ";
}
}
int main() {
vector<int> v;
Input(v);
SwapMax(v);
Output(v);
} | C++ |
#include<iostream>
#include<algorithm>
#include<vector>
using std::vector;
using std::cin;
using std::cout;
using std::iter_swap;
template<typename T>
void Input(vector<T> &v) {
size_t size;
cin >> size;
v.resize(size);
for (size_t i = 0; i < size; ++i) {
cin >> v[i];
}
}
template<typename T>
void SelectionSort(vector<T> &v) {
if (!v.size()) {
return;
}
size_t size = v.size() - 1;
auto end = v.end();
while (size) {
iter_swap(max_element(v.begin(), end), (end - 1));
--end;
--size;
}
}
template<typename T>
void Output(const vector<T> &v) {
for (auto elem : v) {
cout << elem << " ";
}
}
int main() {
vector<int> v;
Input(v);
SelectionSort(v);
Output(v);
} | C++ |
#include<iostream>
#include<algorithm>
#include<vector>
using std::vector;
using std::pair;
using std::make_pair;
using std::iter_swap;
using std::cin;
using std::cout;
using std::endl;
using std::distance;
template <typename T>
void Input(vector<T> &v, int &separator) {
size_t size;
cin >> size;
v.resize(size);
for (size_t i = 0; i < size; ++i) {
cin >> v[i];
}
cin >> separator;
}
template<typename T>
T partition(T left, T right, int separator) {
if (left == right)
return left;
auto begin = left;
auto res = left;
while (left < right) {
if (*left >= separator) {
++left;
}
else {
iter_swap(left, res);
++res;
++left;
}
}
return res;
}
template<typename T>
void Output(vector<T> &v, int separator) {
auto res = partition(v.begin(), v.end(), separator);
int less = distance(v.begin(), res);
if (v.begin() == v.end())
{
cout << "0" << endl << "0";
return;
}
if (v.end() - 1 == res && *res < separator)
++less;
cout << less << endl;;
cout << v.size() - less;
}
int main() {
vector<int> v;
int separator = 0;
Input(v, separator);
Output(v, separator);
} | C++ |
#include<iostream>
#include<vector>
using std::cin;
using std::cout;
using std::vector;
using std::endl;
template<typename T>
void Create_a_graph(int &n, int &a, int &b, vector<vector<T>> &v) {
cin >> n;
v.resize(2 * n);
cin >> a >> b;
for (int i = 0; i < a; ++i) {
int first, second;
cin >> first >> second;
v[2 * (first - 1)].push_back(2 * first - 1);
v[2 * (second - 1)].push_back(2 * second - 1);
v[2 * first - 1].push_back(2 * (second - 1));
}
for (int i = 0; i < b; ++i) {
int first, second;
cin >> first >> second;
v[2 * (first - 1)].push_back(2 * second - 1);
v[2 * (second - 1)].push_back(2 * first - 1);
}
}
template<typename T>
void Top_Sort(T vertex, const vector<vector<T>> &v, vector<T> &used,
vector<T> &order, bool &flag, T pred) {
used[vertex] = 1;
for (int i = 0; i < v[vertex].size(); ++i) {
T to = v[vertex][i];
if (used[to] == 0) {
Top_Sort(to, v, used, order, flag, vertex);
}
if (used[to] == 1) {
flag = true;
return;
}
}
order.push_back(vertex / 2);
used[vertex] = 2;
}
struct point{
int first;
int second;
};
template<typename T>
void Solve(const vector<T> &order, bool fl) {
if (fl) {
cout << "Impossible";
return;
}
vector<point> res;
res.resize(order.size() / 2);
for (int i = 0; i < res.size(); ++i) {
res[i].first = res[i].second = 0;
}
int count = 1;
for (int i = order.size() - 1; i >= 0; --i) {
int ver = order[i];
if (res[ver].first == 0) {
res[ver].first = count++;
}
else {
res[ver].second = count++;
}
}
for (int i = 0; i < res.size(); ++i) {
cout << res[i].first << " " << res[i].second << endl;
}
}
int main() {
int n, a, b;
vector<vector<int>> v;
vector<int> used;
vector<int> order;
bool flag = false;
Create_a_graph(n, a, b, v);
used.resize(v.size());
for (int i = 0; i < v.size(); ++i) {
if (used[i] == 0) {
Top_Sort(i, v, used, order, flag, i);
}
}
Solve(order, flag);
} | C++ |
#include<iostream>
#include<vector>
#include<math.h>
#include<algorithm>
using std::cin;
using std::cout;
using std::vector;
using std::endl;
#define magic 268435459;
template<typename T>
void Input(vector<vector<T>> & table, vector<vector<T>> &count) {
size_t n, m;
cin >> n >> m;
table.resize(n), count.resize(n);
for (size_t i = 0; i < n; ++i) {
for (size_t j = 0; j < m; ++j) {
T next;
cin >> next;
table[i].push_back(next);
count[i].push_back(0);
}
}
count[0][0] = table[0][0];
for (size_t i = 1; i < m; ++i) {
if (table[0][i]) {
count[0][i] = count[0][i - 1];
}
}
for (size_t i = 1; i < n; ++i) {
if (table[i][0]) {
count[i][0] = count[i - 1][0];
}
}
}
template<typename T>
void Solution(const vector<vector<T>> & table, vector<vector<T>> &count) {
for (int i = 1; i < count.size(); ++i) {
for (int j = 1; j < count[i].size(); ++j) {
if (table[i][j]) {
count[i][j] = (count[i - 1][j] + count[i][j - 1]) % magic;
}
}
}
cout << count[count.size() - 1][count[count.size() - 1].size() - 1];
}
int main() {
vector<vector<long long>> table;
vector<vector<long long>> count;
Input(table, count);
Solution(table, count);
} | C++ |
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<queue>
using std::cin;
using std::cout;
using std::vector;
using std::endl;
using std::queue;
template<typename T2>
void Input(vector<vector<T2>> &g, T2 &start, T2 &fin) {
int n, m;
cin >> n;
cin >> m;
vector<vector<T2>> table;
table.resize(n);
T2 x, y;
cin >> x >> y;
--x, --y;
start = (x * m) + y;
cin >> x >> y;
--x, --y;
fin = (x * m) + y;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
T2 next;
cin >> next;
table[i].push_back(next);
}
}
g.resize(n * m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (!table[i][j]) {
if (i && !table[i - 1][j]) {
g[m * i + j].push_back(m * (i - 1) + j);
}
if (i != (n - 1) && !table[i + 1][j]) {
g[m * i + j].push_back(m * (i + 1) + j);
}
if (j && !table[i][j - 1]) {
g[m * i + j].push_back(m * (i)+j - 1);
}
if (j != (m - 1) && !table[i][j + 1]) {
g[m * i + j].push_back(m * i + j + 1);
}
}
}
}
}
template<typename T1>
void Bfs(const vector<vector<T1>> &g, T1 start, vector<T1> &length) {
queue<T1> q;
q.push(start);
while (!q.empty()) {
T1 v = q.front();
q.pop();
for (size_t i = 0; i < g[v].size(); ++i) {
T1 to = g[v][i];
if (to != start && (length[to] == 0 ||
length[to] > length[v] + 1)) {
q.push(to);
length[to] = length[v] + 1;
}
}
}
}
int main() {
vector<vector<int>> g;
int start, fin;
Input(g, start, fin);
vector<int> length;
length.resize(g.size());
Bfs(g, start, length);
if (start == fin) {
cout << "0";
}
else {
if (!length[fin]) {
cout << "NO";
}
else
{
cout << length[fin];
}
}
} | C++ |
#include<iostream>
#include<vector>
#include<math.h>
#include<algorithm>
using std::cin;
using std::cout;
using std::vector;
using std::endl;
template<typename T>
void Input(vector<vector<T>> & table, vector<vector<T>> &cost) {
size_t n, m;
cin >> n >> m;
table.resize(n), cost.resize(n);
for (size_t i = 0; i < n; ++i) {
for (size_t j = 0; j < m; ++j) {
T next;
cin >> next;
table[i].push_back(next);
cost[i].push_back(0);
}
}
cost[0][0] = table[0][0];
for (size_t i = 1; i < m; ++i) {
cost[0][i] = cost[0][i - 1] + table[0][i];
}
for (size_t i = 1; i < n; ++i) {
cost[i][0] = cost[i - 1][0] + table[i][0];
}
}
template<typename T>
void Solution(const vector<vector<T>> & table, vector<vector<T>> &cost) {
for (size_t i = 1; i < cost.size(); ++i) {
for (size_t j = 1; j < cost[i].size(); ++j) {
cost[i][j] = min(cost[i - 1][j], cost[i][j - 1]) + table[i][j];
}
}
cout << cost[cost.size() - 1][cost[cost.size() - 1].size() - 1];
}
int main() {
vector<vector<int>> table;
vector<vector<int>> cost;
Input(table, cost);
Solution(table, cost);
} | C++ |
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<math.h>
using std::cin;
using std::cout;
using std::vector;
using std::endl;
struct point {
double x, y;
};
double length(point a, point b) {
return (sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)));
}
template< typename T1, typename T2>
void Input(vector<T1> &v, vector<vector<T2>> &g) {
size_t n;
cin >> n;
double k;
cin >> k;
g.resize(n);
for (size_t i = 0; i < n; ++i) {
point next;
cin >> next.x >> next.y;
v.push_back(next);
}
for (size_t i = 0; i < n; ++i) {
for (size_t j = 0; j < n; ++j) {
if (i != j && length(v[i], v[j]) <= k)
g[i].push_back(j);
}
}
}
template<typename T1, typename T2>
void Dfs(T1 v, const vector<vector<T1>> &g, vector<T2> &used) {
used[v] = 1;
for (int i = 0; i < g[v].size(); ++i) {
if (!used[g[v][i]]) {
Dfs(g[v][i], g, used);
}
}
}
template<typename T>
void Solve(vector<vector<T>> &g) {
vector<int> used;
used.resize(g.size(), 0);
Dfs(0, g, used);
for (size_t i = 1; i < g.size(); ++i) {
if (!used[i]) {
cout << "NO";
return;
}
}
cout << "YES";
}
int main() {
vector<point> v;
vector<vector<int>> g;
Input(v, g);
Solve(g);
} | C++ |
#include <iostream>
#include <vector>
using std::vector;
using std::cin;
using std::cout;
enum color { WHITE, GREY, BLACK };
class AbstractDoer {
public:
virtual void entering(int vertex) {};
virtual void leaving(int vertex) {};
virtual void grey_edge(int from, int to) {}
virtual void black_edge(int from, int to) {}
virtual void before_iteration(int from, int to) {}
virtual void after_iteration(int from, int to) {}
};
void dfs(const vector<vector<int>>& graph, vector <color>& was, AbstractDoer* Doer, int vertex) {
was[vertex] = GREY;
Doer->entering(vertex);
for (auto next_vertex : graph[vertex]) {
if (was[next_vertex] == GREY)
Doer->grey_edge(vertex, next_vertex);
else if (was[next_vertex] == BLACK) {
Doer->black_edge(vertex, next_vertex);
}
else {
Doer->before_iteration(vertex, next_vertex);
dfs(graph, was, Doer, next_vertex);
Doer->after_iteration(vertex, next_vertex);
}
}
was[vertex] = BLACK;
Doer->leaving(vertex);
}
class Printer : public AbstractDoer {
public:
void entering(int vertex) {
cout << "Entered vertex " << vertex << ". \n";
}
void leaving(int vertex) {
cout << "Left vertex " << vertex << ". \n";
}
};
class BridgesFinder : public AbstractDoer {
public:
int timer;
vector<int> tin, fup;
BridgesFinder(int n):timer(0) {
tin.resize(n, 0);
fup.resize(n, 0);
}
void entering(int vertex) {
tin[vertex] = fup[vertex] = timer++;
}
void grey_edge(int from, int to) {
fup[from] = std::min(fup[from], tin[to]);
}
void black_edge(int from, int to) {
fup[from] = std::min(fup[from], tin[to]);
}
void after_iteration(int from, int to) {
fup[from] = std::min(fup[from], fup[to]);
if (fup[to] > tin[from])
cout << "Bridge: " << from + 1 << " " << to + 1 << std::endl;
}
};
int main() {
int n, m;
cin >> n >> m;
vector <vector<int>> edges;
edges.resize(n);
vector <color> was(n);
for (int i = 0; i < m; ++i) {
int l, r; cin >> l >> r;
--l; --r;
edges[l].push_back(r);
edges[r].push_back(l);
}
auto doer = new BridgesFinder(n);
dfs(edges, was, doer, 1);
} | C++ |
#include <iostream>
#include <vector>
#include <algorithm>
using std::cin;
using std::cout;
using std::endl;
using std::vector;
const int inf = 1e9;
struct Station {
int x, y;
Station(int x = 0, int y = 0): x(x), y(y) {}
friend std::istream& operator>>(std::istream& lin, Station& station) {
lin >> station.x >> station.y;
return lin;
}
};
int sqr(int x) {
return x * x;
}
bool reachable(const Station& one, const Station& two, int k) {
return sqr(one.x - two.x) + sqr(one.y - two.y) <= sqr(k);
}
void dfs(int v, const vector <Station>& stations, vector <bool>& was, int k) {
was[v] = 1;
for (int u = 0; u < stations.size(); ++u) {
if (!was[u]) {
if (reachable(stations[v], stations[u], k))
dfs(u, stations, was, k);
}
}
}
int main() {
int n, k;
cin >> n >> k;
vector <Station> stations(n);
for (int i = 0; i < n; ++i) {
cin >> stations[i];
}
vector <bool> was(n, 0);
dfs(0, stations, was, k);
if ((*std::min_element(was.begin(), was.end())) == 0)
cout << "NO";
else
cout << "YES";
}
| C++ |
#include <iostream>
#include <vector>
#include <algorithm>
using std::cin;
using std::cout;
using std::vector;
class AbstractDoer {
public:
virtual void entering(int vertex) {};
virtual void leaving(int vertex) {};
virtual void if_used(int from, int to) {}
virtual void before_iteration(int from, int to) {}
virtual void after_iteration(int from, int to) {}
};
class TopSort : public AbstractDoer {
public:
vector<int> order;
bool has_cycle;
TopSort() {
order.clear();
has_cycle = false;
}
void if_used(int vertex, int next_vertex) {
has_cycle = true;
}
void leaving(int vertex) {
order.push_back(vertex);
}
};
void dfs(const vector<vector<int>>& graph, vector <int>& was, AbstractDoer* Doer, int vertex, int parent = -1) {
was[vertex] = 1;
Doer->entering(vertex);
for (auto next_vertex : graph[vertex]) {
if (next_vertex == parent)
continue;
if (was[next_vertex] == 1)
Doer->if_used(vertex, next_vertex);
else {
Doer->before_iteration(vertex, next_vertex);
dfs(graph, was, Doer, next_vertex, vertex);
Doer->after_iteration(vertex, next_vertex);
}
}
Doer->leaving(vertex);
was[vertex] = 2;
}
int main() {
int n, a, b;
cin >> n >> a >> b;
vector <vector <int> > e(n * 2 + 1);
vector <int> was(2 * n + 1, 0);
for (int i = 0; i < a; ++i) {
int l, r;
cin >> l >> r;
l--; r--;
e[l * 2 + 1].push_back(r * 2);
}
for (int i = 0; i < b; ++ i) {
int l, r;
cin >> l >> r;
l--; r--;
e[r * 2].push_back(l * 2 + 1);
e[l * 2].push_back(r * 2 + 1);
}
for (int i = 0; i < n; ++i) {
e[i * 2].push_back(i * 2 + 1);
}
auto topsort = new TopSort();
for (int i = 0; i < 2 * n; ++i) {
if (!was[i]) {
dfs(e, was, topsort, i);
}
}
std::reverse(topsort->order.begin(), topsort->order.end());
vector<int> xcoords(2 * n);
for (int i = 0; i < topsort->order.size(); ++ i) {
xcoords[topsort->order[i]] = i;
}
if (topsort->has_cycle)
cout << "Impossible";
else {
for (int i = 0; i < 2 * n; i+=2) {
cout << xcoords[i] << " " << xcoords[i + 1] << std::endl;
}
}
}
| C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
using std::cin;
using std::cout;
using std::endl;
using std::vector;
const int inf = 1e9;
struct Point {
int x, y;
Point(int x = 0, int y = 0): x(x), y(y) {}
friend std::istream& operator>>(std::istream& lin, Point& point) {
lin >> point.x >> point.y;
return lin;
}
};
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
int main() {
int n, m;
cin >> n >> m;
Point start, finish;
cin >> start >> finish;
vector <vector <int>> dist(n + 2);
vector <vector <int>> walls(n + 2);
vector <vector <bool>> was(n + 2);
for (int i = 0; i < n + 2; ++i) {
dist[i].resize(m + 2, inf);
walls[i].resize(m + 2, 1);
was[i].resize(m + 2, 0);
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> walls[i][j];
}
}
dist[start.x][start.y] = 0;
was[start.x][start.y] = 1;
std::queue <Point> q;
q.push(start);
while (!q.empty()) {
auto current = q.front();
q.pop();
for (int i = 0; i < 4; ++i) {
Point to(current.x + dx[i], current.y + dy[i]);
if (!walls[to.x][to.y] && !was[to.x][to.y]) {
q.push(to);
was[to.x][to.y] = true;
dist[to.x][to.y] = dist[current.x][current.y] + 1;
}
}
}
if (dist[finish.x][finish.y] != inf)
cout << dist[finish.x][finish.y] << endl;
else
cout << "NO\n";
}
| C++ |
#include <iostream>
#include <vector>
using std::cin;
using std::cout;
using std::endl;
using std::vector;
const int inf = 1e9;
int main() {
vector<vector<int>> matrix;
vector<vector<int>> dynamics;
int n, m;
cin >> n >> m;
matrix.resize(n + 1);
dynamics.resize(n + 1);
for (int i = 0; i < n + 1; ++i) {
matrix[i].resize(m + 1, 0);
dynamics[i].resize(m + 1, inf);
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> matrix[i][j];
}
}
dynamics[0][1] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
dynamics[i][j] = std::min(dynamics[i - 1][j], dynamics[i][j - 1]) + matrix[i][j];
}
}
cout << dynamics[n][m] << endl;
}
| C++ |
#include <iostream>
#include <vector>
using std::cin;
using std::cout;
using std::endl;
using std::vector;
const int inf = 1e9;
int main() {
vector<vector<int>> matrix;
vector<vector<int>> dynamics;
int n, m;
cin >> n >> m;
matrix.resize(n + 1);
dynamics.resize(n + 1);
for (int i = 0; i < n + 1; ++i) {
matrix[i].resize(m + 1, 0);
dynamics[i].resize(m + 1, 0);
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> matrix[i][j];
}
}
dynamics[0][1] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (matrix[i][j])
dynamics[i][j] = (dynamics[i - 1][j] + dynamics[i][j - 1]) % 268435459;
}
}
cout << dynamics[n][m] << endl;
}
| C++ |
#include <iostream>
#include <vector>
#include <algorithm>
template <typename T>
void read_array(std::vector <T>* input_array) {
int n;
std::cin >> n;
input_array->reserve(n);
for (int i = 0; i < n; ++i) {
T number; std::cin >> number;
input_array->push_back(number);
}
}
template <typename InIt>
InIt my_partition(InIt first, InIt last, int x) {
while (first != last) {
while (*first < x) {
++first;
if (first==last) return first;
}
do {
--last;
if (first==last) return first;
} while (*last > x);
std::swap(*first, *last);
++first;
}
return first;
}
template <typename T>
void quick_sort(T first, T last) {
if (std::distance(first, last) <= 1)
return;
T middle = std::next(first,((long long) rand() * (long long)rand()) % std::distance(first, last));
middle = my_partition(first, last, *middle);
if (!is_sorted(first, middle))
quick_sort(first, middle);
if (!is_sorted(middle, last))
quick_sort(middle, last);
}
int main() {
std::vector <int> input_array;
read_array(&input_array);
quick_sort(input_array.begin(), input_array.end());
for (auto el : input_array) {
std::cout << el << " ";
}
}
| C++ |
#include <iostream>
#include <vector>
template <typename InIt, typename OutIt>
OutIt merge(InIt begin_left, InIt end_left, InIt begin_right, InIt end_right, OutIt dest) {
auto it1 = begin_left, it2 = begin_right;
while (it1 != end_left || it2 != end_right) {
if (it2 == end_right || (it1 != end_left && *it1 < *it2)) {
*dest++ = *it1++;
} else {
*dest++ = *it2++;
}
}
return dest;
}
template <typename InIt>
void merge_sort(InIt begin, InIt end) {
if (distance(begin, end) <= 1)
return;
InIt middle = begin + distance(begin, end) / 2;
std::vector<int> left(begin, middle);
merge_sort(left.begin(), left.end());
std::vector<int> right(middle, end);
merge_sort(right.begin(), right.end());
merge(left.begin(), left.end(), right.begin(), right.end(), begin);
left.clear();
right.clear();
}
template <typename T>
void read_array(std::vector <T>* input_array) {
int n;
std::cin >> n;
input_array->reserve(n);
for (int i = 0; i < n; ++i) {
T number; std::cin >> number;
input_array->push_back(number);
}
}
int main() {
int n;
std::vector <int> input_array;
read_array(&input_array);
merge_sort(input_array.begin(), input_array.end());
for (auto el : input_array) {
std::cout << el << " ";
}
}
| C++ |
#include <iostream>
#include <vector>
template <typename InIt>
InIt my_partition(InIt first, InIt last, int x) {
while (first != last) {
while (*first < x) {
++first;
if (first==last) return first;
}
do {
--last;
if (first==last) return first;
} while (*last >= x);
std::iter_swap(first, last);
++first;
}
return first;
}
template <typename T>
void read_array(std::vector <T>* input_array) {
int n;
std::cin >> n;
input_array->reserve(n);
for (int i = 0; i < n; ++i) {
T number; std::cin >> number;
input_array->push_back(number);
}
}
int main() {
std::vector <int> input_array;
read_array(&input_array);
int k; std::cin >> k;
auto middle = my_partition(input_array.begin(), input_array.end(), k);
std::cout << std::distance(input_array.begin(), middle) << std::endl << std::distance(middle, input_array.end());
}
| C++ |
#include <iostream>
#include <vector>
template <typename T>
void move_max(T begin, T end) {
if (begin == end) {
return;
}
T maximum_position = begin;
for (auto it = begin; it!= end; ++it) {
if (*maximum_position < *it) {
maximum_position = it;
}
}
std::iter_swap(maximum_position, end - 1);
}
template <typename T>
void read_array(std::vector <T>* input_array) {
int n;
std::cin >> n;
input_array->reserve(n);
for (int i = 0; i < n; ++i) {
T number; std::cin >> number;
input_array->push_back(number);
}
}
template <typename T>
void choosing_sort(T begin, T end) {
for (auto it = end; it != begin; --it) {
move_max(begin, it);
}
}
int main() {
std::vector <int> input_array;
read_array(&input_array);
choosing_sort(input_array.begin(), input_array.end());
for (auto el : input_array) {
std::cout << el << " ";
}
}
| C++ |
#include <iostream>
#include <vector>
template <typename T>
void move_max(T begin, T end) {
if (begin == end) {
return;
}
T maximum_position = begin;
for (auto it = begin; it!= end; ++it) {
if (*maximum_position < *it) {
maximum_position = it;
}
}
std::iter_swap(maximum_position, end - 1);
}
template <typename T>
void read_array(std::vector <T>* input_array) {
int n;
std::cin >> n;
input_array->reserve(n);
for (int i = 0; i < n; ++i) {
T number; std::cin >> number;
input_array->push_back(number);
}
}
int main() {
std::vector <int> input_array;
read_array(&input_array);
move_max(input_array.begin(), input_array.end());
for (auto el : input_array) {
std::cout << el << " ";
}
}
| C++ |
#include <iostream>
#include <vector>
template <typename InIt, typename OutIt>
OutIt merge(InIt begin_left, InIt end_left, InIt begin_right, InIt end_right, OutIt dest) {
auto it1 = begin_left, it2 = begin_right;
while (it1 != end_left || it2 != end_right) {
if (it2 == end_right || (it1 != end_left && *it1 < *it2)) {
*dest++ = *it1++;
} else {
*dest++ = *it2++;
}
}
return dest;
}
template <typename T>
void read_array(std::vector <T>* input_array) {
int n;
std::cin >> n;
input_array->reserve(n);
for (int i = 0; i < n; ++i) {
T number; std::cin >> number;
input_array->push_back(number);
}
}
int main() {
std::vector <int> f_array, s_array;
read_array(&f_array);
read_array(&s_array);
std::vector<int> merged(f_array.size() + s_array.size());
merge(f_array.begin(), f_array.end(), s_array.begin(), s_array.end(), merged.begin());
for (auto el : merged) {
std::cout << el << " ";
}
}
| C++ |
trash | C++ |
#include <iostream>
#include <vector>
#include <algorithm>
using std::vector;
using std::cin;
using std::cout;
int FindMax(vector<int> &v, int n) {
int max_coor = 0;
for (int i = 0; i < n; i++) {
if (v[i] > v[max_coor]) {
max_coor = i;
}
}
return max_coor;
}
int main() {
int n;
cin >> n;
if (n == 0) {
return 0;
}
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int max_coor = FindMax(v, n);
std::swap(v[n-1], v[max_coor]);
for (int i = 0; i < n; i++) {
cout << v[i] << ' ';
}
return 0;
} | C++ |
#include <iostream>
#include <vector>
#include <algorithm>
using std::vector;
using std::cin;
using std::cout;
template <typename iter>
iter partition(iter begin, iter end, int x) {
if(end == begin)
return begin;
--end;
while (begin != end) {
if (*begin < x) {
++begin;
continue;
}
if (*end >= x) {
--end;
continue;
}
std::swap(*begin, *end);
}
return begin + (*begin < x);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int x;
cin >> x;
int l = partition(a.begin(), a.end(), x) - a.begin();
cout << l << std::endl << n - l;
return 0;
} | C++ |
#include <iostream>
#include <vector>
#include <algorithm>
using std::vector;
using std::cin;
using std::cout;
template <typename iter>
void merge (iter first_begin, iter first_end, iter second_begin, iter second_end, iter buffer) {
while (first_begin != first_end && second_begin != second_end) {
if (*first_begin < *second_begin) {
*buffer = *first_begin;
++buffer;
++first_begin;
}
else {
*buffer = *second_begin;
++buffer;
++second_begin;
}
}
while (first_begin != first_end) {
*buffer = *first_begin;
++buffer;
++first_begin;
}
while (second_begin != second_end) {
*buffer = *second_begin;
++buffer;
++second_begin;
}
}
template <typename iter>
void sort (iter begin, iter end, iter buffer) {
if(end - begin == 1)
return;
sort(begin, begin + (end - begin) / 2, buffer);
sort(begin + (end - begin) / 2, end, buffer);
merge(begin, begin + (end - begin) / 2, begin + (end - begin), end, buffer);
merge(buffer, buffer + end - begin, end, end, begin);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for(auto elem:a) {
cout << elem << ' ';
}
return 0;
} | C++ |
#include <iostream>
#include <vector>
#include <algorithm>
using std::vector;
using std::cin;
using std::cout;
template <typename iter>
void merge (iter first_begin, iter first_end, iter second_begin, iter second_end, iter buffer) {
while (first_begin != first_end && second_begin != second_end) {
if (*first_begin < *second_begin) {
*buffer = *first_begin;
++buffer;
++first_begin;
}
else {
*buffer = *second_begin;
++buffer;
++second_begin;
}
}
while (first_begin != first_end) {
*buffer = *first_begin;
++buffer;
++first_begin;
}
while (second_begin != second_end) {
*buffer = *second_begin;
++buffer;
++second_begin;
}
}
template <typename iter>
void sort (iter begin, iter end, iter buffer) {
if(end - begin == 1)
return;
sort(begin, begin + (end - begin) / 2, buffer);
sort(begin + (end - begin) / 2, end, buffer);
merge(begin, begin + (end - begin) / 2, begin + (end - begin), end, buffer);
merge(buffer, buffer + end - begin, end, end, begin);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int m;
cin >> m;
vector<int> b(m);
for (int i = 0; i < m; ++i) {
cin >> b[i];
}
vector <int> res(n+m);
merge(a.begin(), a.end(), b.begin(), b.end(), res.begin());
for (int i = 0; i < res.size(); ++i) {
cout << res[i] << ' ';
}
return 0;
} | C++ |
#include <iostream>
#include <vector>
#include <algorithm>
using std::vector;
using std::cin;
using std::cout;
int FindMax(vector<int> &v, int n) {
int max_coor = 0;
for (int i = 0; i < n; i++) {
if (v[i] > v[max_coor]) {
max_coor = i;
}
}
return max_coor;
}
int main() {
int n;
cin >> n;
if (n == 0) {
return 0;
}
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < n; i++) {
int max_coor = FindMax(v, n-i);
std::swap(v[n-1-i], v[max_coor]);
}
for (int i = 0; i < n; i++) {
cout << v[i] << ' ';
}
return 0;
} | C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using std::vector;
using std::cin;
using std::cout;
template <typename iter>
iter add_partition(iter begin, iter end, iter part, int x) {
iter flag = part;
while (begin != flag) {
if (*begin == x) {
std::swap(*begin, *flag);
--flag;
continue;
}
++begin;
}
while (end != part) {
if (*end == x) {
std::swap(*end, *part);
++part;
continue;
}
--end;
}
flag++;
return flag;
}
template <typename iter>
iter partition(iter begin, iter end, int x, int &cnt) {
if(end == begin)
return begin;
--end;
cnt = 0;
iter begin0 = begin, end0 = end;
while (begin != end) {
if (*begin < x) {
++begin;
continue;
}
if (*end >= x) {
if (*end == x) {
++cnt;
}
--end;
continue;
}
std::swap(*begin, *end);
}
if (*end == x) {
++cnt;
}
while (*begin < x)
++begin;
return add_partition(begin0, end0, begin, x);
}
template <typename iter>
void qsort (iter begin, iter end) {
if (end - begin <= 1)
return;
iter mid = begin + std::rand() % (end - begin);
int cnt;
iter part = partition(begin, end, *mid, cnt);
qsort(begin, part);
qsort(part + cnt - 1, end);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
qsort(a.begin(), a.end());
copy(a.begin(), a.end(), std::ostream_iterator<int>(cout, " "));
return 0;
} | C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using std::vector;
using std::cin;
using std::cout;
int din(int n, int m, vector<vector<int> > &dinamic, vector<vector<int> > &a) {
if(n < 0 || m < 0) {
return 1e+9;
}
if (dinamic[n][m] + 1) {
return dinamic[n][m];
}
dinamic[n][m] = a[n][m] + std::min(din(n-1, m, dinamic, a), din(n, m-1, dinamic, a));
return dinamic[n][m];
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int> > a(n), dinamic(n);
for (int i = 0; i < n; ++i) {
a[i].resize(m);
dinamic[i].resize(m, -1);
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
}
}
dinamic[0][0] = a[0][0];
cout << din(n-1, m-1, dinamic, a);
return 0;
} | C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using std::vector;
using std::cin;
using std::cout;
void Input(int &n, int &k, vector<vector<int> > &matrix) {
cin >> n >> k;
vector<std::pair<int, int> > coordinates(n);
for (int i = 0; i < n; ++i) {
cin >> coordinates[i].first >> coordinates[i].second;
}
matrix.resize(n);
for (int i = 0; i < n; ++i) {;
for (int j = 0; j < n; ++j) {
if (k*k >= (coordinates[i].first - coordinates[j].first) * (coordinates[i].first - coordinates[j].first) +
(coordinates[i].second - coordinates[j].second) * (coordinates[i].second - coordinates[j].second)) {
matrix[i].push_back(j);
}
}
}
}
void CreateMarks(vector<int> &marks, int n) {
marks.resize(n, -1);
}
void dfs(vector<vector<int> > &matrix, vector<int> &marks, int n) {
if(marks[n] + 1)
return;
marks[n] = 1;
for (int i = 0; i < matrix[n].size(); ++i) {
dfs(matrix, marks, matrix[n][i]);
}
}
bool check(vector<int> &marks) {
for (int i = 0; i < marks.size(); ++i) {
if (!(marks[i] + 1)) {
return 0;
}
}
return 1;
}
int main() {
int n, k;
vector<vector<int> > matrix;
Input(n, k, matrix);
vector<int> marks;
CreateMarks(marks, n);
dfs(matrix, marks, 0);
if (check(marks) ){
cout << "YES";
}
else {
cout << "NO";
}
return 0;
} | C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using std::vector;
using std::cin;
using std::cout;
struct interval {
int begin;
int end;
};
void Input(int &n, int &a, int &b, vector<vector<int> > &graf) {
cin >> n >> a >> b;
graf.resize(2 * n);
// 2*i - start 2*i + 1 - finish
int first, second;
for (int i = 0; i < n; ++i) {
graf[i * 2].push_back(i * 2 + 1);
}
for (int i = 0; i < a; ++i) {
cin >> first >> second;
--first, --second;
graf[first * 2].push_back(second * 2);
graf[first * 2].push_back(second * 2 + 1);
graf[first * 2 + 1].push_back(second * 2);
graf[first * 2 + 1].push_back(second * 2 + 1);
}
for (int i = 0; i < b; ++i) {
cin >> first >> second;
--first, --second;
graf[second * 2].push_back(first * 2 + 1);
graf[first * 2].push_back(second * 2 + 1);
}
}
bool dfs(vector<vector<int> > const &graf, vector<int> &buffer, vector<int> &marks, int curr) {
if (marks[curr] == 1)
return 0;
if (marks[curr] == 2)
return 1;
marks[curr] = 1;
for (int i = 0; i < graf[curr].size(); ++i) {
if(dfs(graf, buffer, marks, graf[curr][i]))
continue;
return 0;
}
buffer.push_back(curr);
marks[curr] = 2;
return 1;
}
bool TopSort(vector<vector<int> > const &graf, vector<int> &buffer) {
vector<int> marks(graf.size(), 0);
for (int i = 0; i < graf.size(); ++i) {
if (!marks[i]) {
if (dfs(graf, buffer, marks, i)) {
continue;
}
return 0;
}
}
std::reverse(buffer.begin(), buffer.end());
return 1;
}
void MakeIntervals(vector<int> const &buffer, vector<interval> &intervals) {
for (int i = 0; i < buffer.size(); ++i) {
if (buffer[i] % 2) {
intervals[buffer[i] / 2].end = i;
}
else {
intervals[buffer[i] / 2].begin = i;
}
}
}
void Output(vector<interval> const &intervals) {
for (int i = 0; i < intervals.size(); ++i) {
cout << intervals[i].begin << ' ' << intervals[i].end << std::endl;
}
}
int main() {
int n, a, b;
vector<vector<int> > graf;
Input(n, a, b, graf);
vector<int> buffer;
if(!TopSort(graf, buffer)) {
cout << "Impossible";
return 0;
}
vector<interval> intervals(n);
MakeIntervals(buffer, intervals);
Output(intervals);
return 0;
} | C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <queue>
using std::vector;
using std::cin;
using std::cout;
void Input(int &n, int &m, vector<vector<int> > &matrix, int &x_start, int &y_start, int &x_finish, int &y_finish) {
cin >> n >> m;
matrix.resize(n);
cin >> x_start >> y_start >> x_finish >> y_finish;
x_start--;
y_start--;
x_finish--;
y_finish--;
for (int i = 0; i < n; ++i) {
matrix[i].resize(m, 0);
for (int j = 0; j < m; ++j) {
cin >> matrix[i][j];
}
}
}
void CreateMarks(vector<vector<int> > &marks, int n, int m) {
marks.resize(n);
for (int i = 0; i < n; ++i) {
marks[i].resize(m, -1);
}
}
bool check(int x, int y, int n, int m) {
if (x < 0 || y < 0) {
return 0;
}
if (x >= n || y >= m) {
return 0;
}
return 1;
}
void bfs(vector<vector<int> > &matrix, vector<vector<int> > &marks, int x_st, int y_st) {
struct inque {
int x, y, len;
inque(int _x = 0, int _y = 0, int _len = 0) {
x = _x;
y = _y;
len = _len;
}
};
std::queue<inque> q;
q.push(inque(x_st, y_st, 0));
int x, y, l;
int shift[2];
shift[0] = 1;
shift[1] = -1;
inque current;
while (q.size()) {
current = q.front();
x = current.x;
y = current.y;
l = current.len;
q.pop();
if (!check(x, y, matrix.size(), matrix[0].size())) {
continue;
}
if (marks[x][y] + 1 || matrix[x][y]) {
continue;
}
marks[x][y] = l;
for (int i = 0; i < 2; ++i) {
q.push(inque(x + shift[i], y, l + 1));
q.push(inque(x, y + shift[i], l + 1));
}
}
}
int main() {
int n, m, x_start, y_start, x_finish, y_finish;
vector<vector<int> > matrix;
Input(n, m, matrix, x_start, y_start, x_finish, y_finish);
vector<vector<int> > marks;
CreateMarks(marks, n, m);
bfs(matrix, marks, x_start, y_start);
if (marks[x_finish][y_finish] + 1) {
cout << marks[x_finish][y_finish];
}
else {
cout << "NO";
}
return 0;
} | C++ |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using std::vector;
using std::cin;
using std::cout;
long long din(int n, int m, vector<vector<long long> > &dinamic, vector<vector<long long> > &a) {
if(n < 0 || m < 0) {
return 0;
}
if (dinamic[n][m] + 1) {
return dinamic[n][m];
}
dinamic[n][m] = (a[n][m] * (din(n-1, m, dinamic, a) + din(n, m-1, dinamic, a))) % 268435459;
return dinamic[n][m];
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<long long> > a(n), dinamic(n);
for (int i = 0; i < n; ++i) {
a[i].resize(m);
dinamic[i].resize(m, -1);
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
}
}
dinamic[0][0] = a[0][0];
cout << din(n-1, m-1, dinamic, a);
return 0;
} | C++ |
#include <iostream>
#include <random>
#include <set>
using namespace std;
int generate() {
while (true) {
int n = rand() % 10000;
int curr = n;
set<int> numbers;
while (curr) {
numbers.insert(curr%10);
curr /= 10;
}
if (numbers.size() == 4) {
return n;
}
}
}
int count_bulls(int n, int k) {
int cnt = 0;
while (n && k) {
cnt += (n % 10 == k % 10)
n /= 10;
k /= 10;
}
}
int count_cows(int n, int k) {
set<int> s;
while (n && k) {
s.insert(n % 10), s.insert(k % 10);
n /= 10;
k /= 10;
}
cout << 8 - s.size();
}
void game(int n) {
while (true) {
int k;
cin >> k;
if(n == k) {
cout << "win";
return 0;
}
cout << "cows: " count_cows(n, k) - count_bulls(n, k) << '\n'
<<"bulls: " << count_bulls(n, k) << '\n';
}
}
int main() {
int n = generate();
game(n)
} | C++ |
#include <iostream>
#include <vector>
using std::cin;
using std::cout;
using std::vector;
using std::swap;
void Input(vector <int> *list) {
int count;
cin >> count;
list->reserve(count);
int element;
for (int i(0); i < count; ++i) {
cin >> element;
list->push_back(element);
}
}
template <typename iterator = vector <int>::iterator>
void Swap_max(iterator iterator_begin, iterator iterator_end) {
if (iterator_begin != iterator_end) {
auto max_current = iterator_begin;
for (auto i = iterator_begin; i != iterator_end; ++i) {
if (*max_current < *i) {
max_current = i;
}
}
iter_swap(max_current, iterator_end - 1);
}
}
void Output(vector <int> *list) {
for (auto i = list->begin(); i != list->end(); ++i) {
cout << *i << " ";
}
}
int main() {
vector <int> list;
Input(&list);
Swap_max(list.begin(), list.end());
Output(&list);
} | C++ |
#include <iostream>
#include <vector>
#include <ctime>
using std::cin;
using std::cout;
using std::vector;
using std::swap;
using std::distance;
void Input(vector <int> *list) {
int count;
cin >> count;
list->reserve(count);
int element;
for (int i(0); i < count; ++i) {
cin >> element;
list->push_back(element);
}
}
void Output(vector <int>::iterator iterator_begin,
vector <int>::iterator iterator_end) {
for (auto i = iterator_begin; i != iterator_end; ++i) {
cout << *i << " ";
}
}
template <typename type = int,typename iterator = vector <int>::iterator>
iterator Partition(iterator iterator_begin,
iterator iterator_end, type pivot) {
if (iterator_begin == iterator_end) {
return iterator_begin;
}
iterator iterator_first = iterator_begin;
iterator iterator_last = iterator_end;
auto iterator_current = iterator_begin;
while (iterator_current != iterator_last) {
if (*iterator_current < pivot) {
iter_swap(iterator_current, iterator_first);
++iterator_first;
++iterator_current;
}
else if (*iterator_current > pivot) {
--iterator_last;
iter_swap(iterator_current, iterator_last);
}
else {
++iterator_current;
}
}
return iterator_first;
}
int main() {
srand(time(NULL));
vector <int> list;
int average;
Input(&list);
cin >> average;
auto less = distance(list.begin(), Partition(list.begin(), list.end(), average));
cout << less << std::endl << distance(list.begin(), list.end()) - less;
} | C++ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.