void widget::visible(bool visible)
{
if (impl_->visible_ == visible)
return;
if (visible)
{
if (!onShowing())
return;
if (impl_->father_ && !impl_->father_->onChildShowing(this))
return;
impl_->visible_ = true;
onShown();
if (father())
father()->onChildShown(this);
}
else
{
if (!onHiding())
return;
if (impl_->father_ && !impl_->father_->onChildHiding(this))
return;
impl_->visible_ = false;
onHidden();
if (father())
father()->onChildHidden(this);
}
window().visible(visible);
repaint();
}
node * brother(node *nd)
{
if(!father(nd))
return NULL;
if(isleft(nd))
return right(father(nd));
return left(father(nd));
}
int main(){
scanf("%d%d", &n, &m);
for(int i = 1; i <= n; ++i)
fa[i] = i;
while(m--){
scanf("%d%d", &a, &b);
if(father(a) == father(b))
ans <<= 1;
fa[father(a)] = father(b);
printf("%lld\n", ans - 1);
}
return 0;
}
void slide_up(const vertex &v, const T &value)
{
/* Jesteśmy w korzeniu, nie ma gdzie wyżej jechać. */
if (v == 1) {
array[v] = value;
return;
}
/* Jeżeli podstawienie wartości może zaburzyć porządek - rekurencja. */
if (value < array[father(v)]) {
array[v] = array[father(v)];
slide_up(father(v), value);
} else {
array[v] = value;
}
}
bool widget::as_window(cross_platform_window::Handle handle)
{
if (father())
return false;
if (is_window())
return true;
if (handle)
{
if (takisy::all_windows__.find(handle) == takisy::all_windows__.end())
{
cross_platform_window window(handle);
window.xy(xy() - window.client_offset());
window.client_size(size());
window.visible(visible());
window.repaint();
takisy::all_windows__[handle] = this;
}
}
else
{
handle = takisy::handleFromLPWIDGET(this);
if (handle)
{
takisy::all_windows__.erase(handle);
cross_platform_window(handle).repaint();
}
}
return true;
}
bool widget::as_window(bool enable_alpha_channel)
{
if (father())
return false;
if (is_window())
return true;
cross_platform_window::Handle handle = nullptr;
#ifdef __os_win__
DWORD style = WS_POPUP;
if (visible())
style |= WS_VISIBLE;
DWORD exstyle = WS_EX_TOOLWINDOW;
if (enable_alpha_channel)
exstyle |= WS_EX_LAYERED;
handle = CreateWindowEx(exstyle, takisy::class_name__,
"takisy::gui::cross_platform_window::winnt::widget",
style, x(), y(), width(), height(),
GetDesktopWindow(), nullptr,
GetModuleHandle(nullptr), nullptr);
#endif
if (!handle)
return false;
else
return as_window(handle);
}
bool VValueBag::ReplaceElementByPath( const VValueBag::StKeyPath& inPath, VValueBag *inBag)
{
if (!testAssert( !inPath.empty()))
return false;
bool ok;
if (inPath.size() > 1)
{
VValueBag::StKeyPath father( inPath);
father.pop_back();
if (inBag == NULL)
{
// removing
VValueBag *fatherBag = GetUniqueElementByPath( father);
if (fatherBag != NULL)
fatherBag->RemoveElements( inPath.back());
ok = true;
}
else
{
VValueBag *fatherBag = GetElementByPathAndCreateIfDontExists( father);
if (fatherBag != NULL)
ok = fatherBag->ReplaceElement( inPath.back(), inBag);
else
ok = false;
}
}
else
{
ok = ReplaceElement( inPath.back(), inBag);
}
return ok;
}
/**
* @brief BTRecordFile::readRecordFromDiskTest
* @param pDisk
* @param pRecordID
* Hace la lectura de un registro en la RAM
*/
void BTRecordFile::readRecordFromDiskTest(Disk pDisk, unsigned short pRecordID)
{
const char *padre = pDisk.read(this->_metadataPtr->getFirstRecordPos(), 7);
const char *hizq = pDisk.read(this->_metadataPtr->getFirstRecordPos() + 8, 7);
const char *hder = pDisk.read(this->_metadataPtr->getFirstRecordPos() + 16, 7);
std::string father(padre); // obtiene el padre
std::string HI(hizq); // obtiene el hijo izq
std::string HD(hder); // obtiene el hijo der
unsigned short _sizeCounter = this->_metadataPtr->getFirstRecordPos() + 24; // inicio de la data
DLL<IRecordDataType*> *tmp1 = _metadataPtr->getRecordStruct();
DLLNode<IRecordDataType*> *tmp = tmp1->getHeadPtr();
const char *data;
cout << "Binario " << father << " " << HI << " " << HD << endl;
std::string P = _conversion->binaryToDecimal(father);
std::string PHI = _conversion->binaryToDecimal(HI);
std::string PHD = _conversion->binaryToDecimal(HD);
cout << P << " " << PHI << " " << PHD << " ";
while (tmp != nullptr) {
data = (dynamic_cast<RecordDataType<char>*>(tmp->getData()))->getDataPtr();
const char *DATO = pDisk.read(_sizeCounter, 7);
std::string DATOSTR(DATO); // obtiene el padre
_sizeCounter += 8;
cout << sortUserDataFromDisk(DATOSTR, *data) << endl;
tmp = tmp->getNextPtr();
}
}
/**
\fn analyzeTracks
\brief Read Tracks Info.
*/
uint8_t mkvHeader::analyzeTracks(void *head,uint32_t headlen)
{
uint64_t id,len;
ADM_MKV_TYPE type;
const char *ss;
ADM_ebml_file father( (ADM_ebml_file *)head,headlen);
while(!father.finished())
{
father.readElemId(&id,&len);
if(!ADM_searchMkvTag( (MKV_ELEM_ID)id,&ss,&type))
{
printf("[MKV] Tag 0x%x not found (len %llu)\n",id,len);
father.skip(len);
continue;
}
ADM_assert(ss);
if(id!=MKV_TRACK_ENTRY)
{
printf("[MKV] skipping %s\n",ss);
father.skip(len);
continue;
}
if(!analyzeOneTrack(&father,len)) return 0;
}
return 1;
}
void test() {
parent_ptr father(new parent());
children_ptr son(new children());
father->children = son;
son->parent = father;
}
void father(char *svname, int loop)
{
pid_t p_id;
int killed = 0;
p_id = fork();
if (p_id < 0)
{
printf("Fork failed in svwatch.\n");
exit (-1);
}
if (p_id > 0)
{
printf("Luke, I'm your father.\n");
while (loop && !killed)
{
if (waitpid(p_id, NULL, WNOHANG) > 0)
{
killed = 1;
logvalue(p_id, svname);
father(svname, loop);
}
}
}
if (p_id == 0)
child(svname);
}
void Node::decisions(DecisionList& result) const {
if (!isRoot()) {
result.push_front(_decision);
father()->decisions(result);
}
}
int exec_pipe(int i, char **command)
{
int pid;
int fd[2];
if (command[i + 1])
{
if (pipe(fd) == -1 || (pid = fork()) == -1)
return (0);
if (pid != 0)
{
close(fd[1]);
if (dup2(fd[0], 0) == -1)
return (0);
waitpid(pid, 0, 0);
if (my_pipe(i + 1, command) == 0)
return (0);
close(fd[0]);
}
else if (father(fd, command, i) == 0)
return (0);
}
if (execlp(command[i], command[i], NULL) == -1)
return (0);
return (1);
}
// -------------------------------------------------------------------
// insert element at end of heap and fixup heap by walk towards root
//
void insertHeap( Heap h, void* value )
{
// expand if necessary to accommodate a new node
if ( end(h) == h->maxsize ) { // no more available slots
h->maxsize *= 2;
h->node = safe_realloc( h->node, h->maxsize * sizeof(void*) );
}
// create a hole at end of heap
int hole = end(h);
h->cursize++;
// move hole upwards to place where new value goes
while (hole != root) {
// test if value belongs in hole
int scan = father(hole);
if (h->comp( h->node[ scan ], value ) <= 0) // yes
break;
// no, move hole up one level
h->node[ hole ] = h->node[ scan ];
hole = scan;
}
// fill hole with new element
h->node[ hole ] = value;
}
void Node::decisions(DecisionSet&result) const {
if (!isRoot()) {
result.insert(_decision);
father()->decisions(result);
}
}
/* 建堆 */
static void build_heap(int *heap, int size, fun compare)
{
int index = father(size - 1);
for (; index >= 0; --index)
heapify(heap, index, size, compare);
}
widget::~widget(void)
{
for (widget* child : children())
child->father(nullptr);
father(nullptr);
as_window(nullptr);
delete impl_;
}
/** reorganize the heap
*
* @param i - index from which the reorganization start
*/
inline void reorganize_heap( uint64_t i )
{
uint64_t select;
// checks if some node must be put to the top
while(i > 0 && (heap_t[i].value > heap_t[father( i )].value)){
swap( &heap_t[i], &heap_t[father( i )] );
i = father( i );
}
// checks if some node must be put on the bottom
while(left_node( i ) < heap_size && i != max_father_children( i )){
select = max_father_children( i );
swap( &heap_t[i], &heap_t[select] );
i = select;
}
}
bool widget::is_senior(widget* widget) const
{
class widget* w = father();
while (w && w != widget)
w = w->father();
return w;
}
/**
\fn checkHeader
\brief Check that we are compatible with that version of matroska. At the moment, just dump some infos.
*/
uint8_t mkvHeader::checkHeader(void *head,uint32_t headlen)
{
printf("[MKV] *** Header dump ***\n");
ADM_ebml_file father( (ADM_ebml_file *)head,headlen);
walk(&father);
printf("[MKV] *** End of Header dump ***\n");
return 1;
}
void run() {
pid = fork();
if (pid < 0) {
die("fork: %m");
} else if (pid == 0) {
child();
} else {
father();
}
}
int main (int argc,
char **argv)
{
int loop = 1;
char *svname;
svname = set_svname(argc, argv, &loop);
init_act(svname);
father(svname, loop);
}
int countComponents(int n, vector<pair<int, int>>& edges) {
vector<int> father(n);
vector<int> size(n,1);
for(int i = 0 ; i < n; ++i) father[i] = i;
for(auto &edge: edges) {
Union(edge.first, edge.second, father, size);
}
int cnt = 0;
for(int i = 0; i < n; ++i) if(father[i] == i) ++cnt;
return cnt;
}
int main(int argc, char** argv) {
familyNode
mather("valentina","hotchenkova",59,true,0),
father("alexandr","hotchenkov",58,false,0),
first_son("maxim","hotchenkov",34,false,&mather),
junior_son("alexey","hotchenkov",24,false,&mather),
junior_son_girl_friend("irina","kilchevskaya",20,true,0),
wife_first_son("nataly","hotchenkova",30,true,0),
first_niece("anna","hotchenkova",5,true,&first_son),
junior_nience("olga","hotchenkova",2,true,&first_son);
return 0;
}
__INLINE ElementRef
ElementRef::getFather ()
{
if (getElementPtr() == getDocument().rootElementPtr)
{
return ElementRef(getDocument());
}
ElementRef father( document, getMe<Read>()->fatherPtr);
#ifdef __XEM_DOM_NODEREF_CHROOT_USING_XEMINT_ROOT
if ( 0 && father && father.getKeyId() == getKeyCache().getBuiltinKeys().xemint.root())
{
return ElementRef(getDocument(), 0);
}
#endif // __XEM_DOM_NODEREF_CHROOT_USING_XEMINT_ROOT
return father;
}
int main(void) {
short int i;
srand(time(NULL));
initialize();
puts("To πρόγραμμα εξυπηρετεί Χ αιτήσεις όπου Χ ένας τυχαίος αριθμός");
puts("αιτήσεων ο οποίος δημιουργήθηκε σε n δευτερόλεπτα.");
puts("\nΣημείωση:");
puts("Ο χρόνος που θα δημιουργεί αιτήσεις δεν εχει σχέση με τον χρόνο");
puts("που θα εκτελείται το πρόγραμμα");
puts("\nΕισήγαγε τα n δευτερόλεπτα που το πρόγραμμα θα δημιουργεί");
puts("αιτήσεις:");
/* Εισήγαγε μη μηδενική τιμή */
do {
scanf("%d", &EndTime);
} while (EndTime < 0);
for (i = 0; i < 10; i++) {
pid_c[i] = fork();
switch (pid_c[i]) {
case 0:
childs(i);
flag_c = TRUE;
break; //case break
case -1:
perror("Fork SSTF");
return Error;
}
//Αν είσαι παιδί κάνε break απ'το for
if (flag_c == TRUE) {
break;
}
}
if (flag_c == FALSE) {
father();
}
return (EXIT_SUCCESS);
}
/**
* @param n an integer
* @param m an integer
* @param operators an array of point
* @return an integer array
*/
vector<int> numIslands2(int n, int m, vector<Point> &operators) {
// Write your code here
vector<int> res;
if(n == 0 || m == 0) return res;
vector<vector<int>> grid(n, vector<int>(m, 0));
vector<int> father(n * m, -1);
int sz = operators.size();
for(int i = 0; i < sz; i++) {
int x = operators[i].x;
int y = operators[i].y;
grid[x][y] = 1;
int t = x * m + y;
int ft = find(father, t);
if(i == 0) {
res.push_back(1);
continue;
}
unordered_set<int> s;
for(int k = 0; k < 4; k++) {
int nx = x + dx[k];
int ny = y + dy[k];
int nt = nx * m + ny;
if(!inBound(nx, ny, n, m)) continue;
if(grid[nx][ny] == 0) continue;
s.insert(find(father, nt));
}
res.push_back(res.back() + 1 - s.size());
for(int k = 0; k < 4; k++) {
int nx = x + dx[k];
int ny = y + dy[k];
int nt = nx * m + ny;
if(!inBound(nx, ny, n, m)) continue;
if(grid[nx][ny] == 0) continue;
ft = find(father, t);
int fnt = find(father, nt);
father[ft] = min(ft, fnt);
father[fnt] = min(ft, fnt);
}
}
return res;
}
vector<int> numIslands2(int m, int n, vector<pair<int, int>>& positions) {
vector<int> res;
if(n == 0 || m == 0) return res;
vector<int> father(n * m, -1);
vector<int> rank(n * m, 0);
int sz = positions.size();
for(int i = 0; i < sz; i++) {
int x = positions[i].first;
int y = positions[i].second;
int t = x * n + y;
int ft = find(father, t);
if(i == 0) {
res.push_back(1);
continue;
}
int cnt = res.back() + 1;
for(int k = 0; k < 4; k++) {
int nx = x + dx[k];
int ny = y + dy[k];
int nt = nx * n + ny;
if(!inBound(nx, ny, m, n)) continue;
if(father[nt] == -1) continue;
ft = find(father, t);
int fnt = find(father, nt);
if(ft != fnt) {
cnt--;
if(rank[ft] < rank[fnt]) {
father[ft] = fnt;
} else if(rank[fnt] < rank[ft]) {
father[fnt] = ft;
} else {
father[ft] = fnt;
rank[fnt]++;
}
}
}
res.push_back(cnt);
}
return res;
}
int main(int argc, char *argv[]) {
char *cmd;
if (argc < 2) {
cmd = "/bin/sh";
}
else {
cmd = argv[1];
}
int master_fd = create_master();
if (master_fd < 0) {
return -1;
}
char *pts = ptsname(master_fd);
printf("master = %d\n", master_fd);
printf("cpath = %s\n", pts);
int slave_fd = open(pts, O_RDWR);
pid_t pid = fork();
if (pid > 0) {
// Father
close(slave_fd);
father(master_fd);
}
else if (pid == 0) {
// Child
close(master_fd);
child(slave_fd, pts, cmd);
}
else {
perror("fork");
return -1;
}
return 0;
}
void GTPopulation::reproduction()
{
vector<GTOrganism*> newOrganisms;
for(unsigned int i{0}; i < organisms.size(); ++i)
{
int m{getRnd(0, matingPool.size() - 1)};
int d{getRnd(0, matingPool.size() - 1)};
GTOrganism& mother(*matingPool[m]);
GTOrganism& father(*matingPool[d]);
GTDna childDna{mother.dna.crossover(father.dna)};
childDna.mutate(mutationRate);
newOrganisms.push_back(new GTOrganism{childDna});
}
for(const auto& o : organisms) delete o;
organisms = newOrganisms;
++generation;
}
