void joint(int u, int v) {
u = get_ancestor(u);
v = get_ancestor(v);
if (u != v) {
ancestor[u] = v;
}
}
int main() {
freopen("truth.in", "r", stdin);
freopen("truth.out", "w", stdout);
scanf("%d%d", &n, &m);
for (int i = 1; i <= n + n; ++ i) {
ancestor[i] = i;
}
int count = 1;
while (count <= m) {
int a, b;
char buffer[2];
scanf("%d%d%s", &a, &b, buffer);
if (*buffer == 'T') {
joint(a, b);
joint(a + n, b + n);
} else {
joint(a, b + n);
joint(a + n, b);
}
bool flag = true;
for (int i = 1; i <= n && flag; ++ i) {
flag &= get_ancestor(i) != get_ancestor(i + n);
}
if (!flag) {
break;
}
count ++;
}
printf("%d\n", count - 1);
return 0;
}
static int imap_fetch_body(mailmessage * msg_info,
char ** result, size_t * result_len)
{
char key[PATH_MAX];
char filename[PATH_MAX];
int r;
char * str;
size_t len;
generate_key_from_message(key, PATH_MAX,
msg_info, MAILIMAP_MSG_ATT_RFC822_TEXT);
build_cache_name(filename, PATH_MAX, msg_info, key);
r = generic_cache_read(filename, &str, &len);
if (r == MAIL_NO_ERROR) {
* result = str;
* result_len = len;
return MAIL_NO_ERROR;
}
r = mailmessage_fetch_body(get_ancestor(msg_info), result,
result_len);
if (r == MAIL_NO_ERROR)
generic_cache_store(filename, * result, * result_len);
return r;
}
static int nntpdriver_cached_parameters(mailsession * session,
int id, void * value)
{
struct nntp_cached_session_state_data * cached_data;
int r;
cached_data = get_cached_data(session);
switch (id) {
case NNTPDRIVER_CACHED_SET_CACHE_DIRECTORY:
strncpy(cached_data->nntp_cache_directory, value, PATH_MAX);
cached_data->nntp_cache_directory[PATH_MAX - 1] = '\0';
r = generic_cache_create_dir(cached_data->nntp_cache_directory);
if (r != MAIL_NO_ERROR)
return r;
return MAIL_NO_ERROR;
case NNTPDRIVER_CACHED_SET_FLAGS_DIRECTORY:
strncpy(cached_data->nntp_flags_directory, value, PATH_MAX);
cached_data->nntp_flags_directory[PATH_MAX - 1] = '\0';
r = generic_cache_create_dir(cached_data->nntp_flags_directory);
if (r != MAIL_NO_ERROR)
return r;
return MAIL_NO_ERROR;
default:
return mailsession_parameters(get_ancestor(session), id, value);
}
}
static int
nntpdriver_cached_get_messages_list(mailsession * session,
struct mailmessage_list ** result)
{
return nntp_get_messages_list(get_ancestor(session), session,
nntp_cached_message_driver, result);
}
static int imap_fetch_section_body(mailmessage * msg_info,
struct mailmime * mime,
char ** result,
size_t * result_len)
{
char key[PATH_MAX];
char filename[PATH_MAX];
int r;
char * str;
size_t len;
generate_key_from_section(key, PATH_MAX,
msg_info, mime, IMAP_SECTION_BODY);
build_cache_name(filename, PATH_MAX, msg_info, key);
r = generic_cache_read(filename, &str, &len);
if (r == MAIL_NO_ERROR) {
* result = str;
* result_len = len;
return MAIL_NO_ERROR;
}
r = mailmessage_fetch_section_body(get_ancestor(msg_info),
mime, result, result_len);
if (r == MAIL_NO_ERROR)
generic_cache_store(filename, * result, * result_len);
return r;
}
int main() {
freopen("msched.in", "r", stdin);
freopen("msched.out", "w", stdout);
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++ i) {
scanf("%d", cost + i);
ancestor[i] = i;
}
while (m --) {
int u, v;
scanf("%d%d", &u, &v);
neighbors[u].push_back(v);
degree[v] ++;
joint(u, v);
}
int tail = 0;
for (int i = 1; i <= n; ++ i) {
if (degree[i] == 0) {
dp[i] = cost[i];
queue[++ tail] = i;
}
}
for (int head = 1; head <= tail; ++ head) {
int u = queue[head];
int du = get_ancestor(u);
final[du] = std::max(final[du], dp[u]);
for (int i = 0; i < neighbors[u].size(); ++ i) {
int v = neighbors[u][i];
dp[v] = std::max(dp[v], dp[u] + cost[v]);
degree[v] --;
if (degree[v] == 0) {
queue[++ tail] = v;
}
}
}
static int imap_fetch_envelope(mailmessage * msg_info,
struct mailimf_fields ** result)
{
struct mailimf_fields * fields;
int r;
struct mail_cache_db * cache_db;
MMAPString * mmapstr;
char filename[PATH_MAX];
struct imap_cached_session_state_data * data;
int res;
data = get_cached_session_data(msg_info);
if (data->imap_quoted_mb == NULL) {
res = MAIL_ERROR_BAD_STATE;
goto err;
}
snprintf(filename, PATH_MAX, "%s/%s", data->imap_quoted_mb, ENV_NAME);
r = mail_cache_db_open_lock(filename, &cache_db);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto err;
}
mmapstr = mmap_string_new("");
if (mmapstr == NULL) {
res = MAIL_ERROR_MEMORY;
goto close_db;
}
r = imapdriver_get_cached_envelope(cache_db, mmapstr,
msg_info->msg_session, msg_info, &fields);
if ((r != MAIL_ERROR_CACHE_MISS) && (r != MAIL_NO_ERROR)) {
res = r;
goto close_db;
}
r = mailmessage_fetch_envelope(get_ancestor(msg_info), &fields);
if (r != MAIL_NO_ERROR) {
res = r;
goto close_db;
}
r = imapdriver_write_cached_envelope(cache_db, mmapstr,
msg_info->msg_session, msg_info, fields);
* result = fields;
mmap_string_free(mmapstr);
mail_cache_db_close_unlock(filename, cache_db);
return MAIL_NO_ERROR;
close_db:
mail_cache_db_close_unlock(filename, cache_db);
err:
return res;
}
static int pop3driver_cached_logout(mailsession * session)
{
struct pop3_cached_session_state_data * cached_data;
cached_data = get_cached_data(session);
pop3_flags_store_process(cached_data->pop3_flags_directory,
cached_data->pop3_flags_store);
return mailsession_logout(get_ancestor(session));
}
static int pop3driver_cached_connect_stream(mailsession * session,
mailstream * s)
{
int r;
r = mailsession_connect_stream(get_ancestor(session), s);
if (r != MAIL_NO_ERROR)
return r;
return MAIL_NO_ERROR;
}
static int imap_get_flags(mailmessage * msg_info,
struct mail_flags ** result)
{
int r;
struct mail_flags * flags;
if (msg_info->msg_flags != NULL) {
* result = msg_info->msg_flags;
return MAIL_NO_ERROR;
}
r = mailmessage_get_flags(get_ancestor(msg_info), &flags);
if (r != MAIL_NO_ERROR)
return r;
get_ancestor(msg_info)->msg_flags = NULL;
msg_info->msg_flags = flags;
* result = flags;
return MAIL_NO_ERROR;
}
static int nntpdriver_cached_logout(mailsession * session)
{
struct nntp_cached_session_state_data * cached_data;
struct nntp_session_state_data * ancestor_data;
cached_data = get_cached_data(session);
ancestor_data = get_ancestor_data(session);
nntp_flags_store_process(cached_data->nntp_flags_directory,
ancestor_data->nntp_group_name,
cached_data->nntp_flags_store);
return mailsession_logout(get_ancestor(session));
}
static int pop3driver_cached_login_sasl(mailsession * session,
const char * auth_type,
const char * server_fqdn,
const char * local_ip_port,
const char * remote_ip_port,
const char * login, const char * auth_name,
const char * password, const char * realm)
{
return mailsession_login_sasl(get_ancestor(session), auth_type,
server_fqdn,
local_ip_port,
remote_ip_port,
login, auth_name,
password, realm);
}
static int mhdriver_cached_logout(mailsession * session)
{
int r;
struct mh_cached_session_state_data * cached_data;
r = write_max_uid_value(session);
cached_data = get_cached_data(session);
mh_flags_store_process(cached_data->mh_flags_directory,
cached_data->mh_quoted_mb,
cached_data->mh_flags_store);
return mailsession_logout(get_ancestor(session));
}
static int nntpdriver_cached_select_folder(mailsession * session, const char * mb)
{
int r;
struct nntp_session_state_data * ancestor_data;
struct nntp_cached_session_state_data * cached_data;
int res;
char key[PATH_MAX];
cached_data = get_cached_data(session);
ancestor_data = get_ancestor_data(session);
nntp_flags_store_process(cached_data->nntp_flags_directory,
ancestor_data->nntp_group_name,
cached_data->nntp_flags_store);
r = mailsession_select_folder(get_ancestor(session), mb);
if (r != MAIL_NO_ERROR)
return r;
if (ancestor_data->nntp_group_name == NULL)
return MAIL_ERROR_BAD_STATE;
snprintf(key, PATH_MAX, "%s/%s", cached_data->nntp_cache_directory,
ancestor_data->nntp_group_name);
r = generic_cache_create_dir(key);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
snprintf(key, PATH_MAX, "%s/%s", cached_data->nntp_flags_directory,
ancestor_data->nntp_group_name);
r = generic_cache_create_dir(key);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
return MAIL_NO_ERROR;
err:
return res;
}
static int mhdriver_cached_select_folder(mailsession * session, const char * mb)
{
int r;
int res;
char * quoted_mb;
struct mh_cached_session_state_data * cached_data;
cached_data = get_cached_data(session);
mh_flags_store_process(cached_data->mh_flags_directory,
cached_data->mh_quoted_mb,
cached_data->mh_flags_store);
quoted_mb = NULL;
r = get_cache_directory(session, mb, "ed_mb);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
r = mailsession_select_folder(get_ancestor(session), mb);
if (r != MAIL_NO_ERROR) {
res = r;
goto free;
}
r = write_max_uid_value(session);
free_state(cached_data);
cached_data->mh_quoted_mb = quoted_mb;
r = read_max_uid_value(session);
return MAIL_NO_ERROR;
free:
free(quoted_mb);
err:
return res;
}
static int mhdriver_cached_move_message(mailsession * session,
uint32_t num, const char * mb)
{
return mailsession_move_message(get_ancestor(session), num, mb);
}
static int imap_get_bodystructure(mailmessage * msg_info,
struct mailmime ** result)
{
int r;
char key[PATH_MAX];
char filename[PATH_MAX];
char * str;
size_t len;
if (msg_info->msg_mime != NULL) {
* result = msg_info->msg_mime;
return MAIL_NO_ERROR;
}
generate_key_from_message(key, PATH_MAX,
msg_info, MAILIMAP_MSG_ATT_BODYSTRUCTURE);
build_cache_name(filename, PATH_MAX, msg_info, key);
r = generic_cache_read(filename, &str, &len);
if (r == MAIL_NO_ERROR) {
size_t cur_index;
struct mailmime * mime;
cur_index = 0;
r = mailmime_parse(str, len, &cur_index, &mime);
mmap_string_unref(str);
cleanup_mime(mime);
msg_info->msg_mime = mime;
* result = mime;
return MAIL_NO_ERROR;
}
r = mailmessage_get_bodystructure(get_ancestor(msg_info),
result);
if (r == MAIL_NO_ERROR) {
int col;
FILE * f;
msg_info->msg_mime = get_ancestor(msg_info)->msg_mime;
get_ancestor(msg_info)->msg_mime = NULL;
f = fopen(filename, "w");
if (f == NULL) {
return MAIL_ERROR_FILE;
}
col = 0;
r = mailmime_write(f, &col, msg_info->msg_mime);
if (r != MAILIMF_NO_ERROR) {
fclose(f);
return MAIL_ERROR_FILE;
}
fclose(f);
}
return r;
}
static int mhdriver_cached_rename_folder(mailsession * session, const char * mb,
const char * new_name)
{
return mailsession_rename_folder(get_ancestor(session), mb, new_name);
}
static int mhdriver_cached_connect_path(mailsession * session, const char * path)
{
return mailsession_connect_path(get_ancestor(session), path);
}
static int imap_fetch_size(mailmessage * msg_info,
size_t * result)
{
return mailmessage_fetch_size(get_ancestor(msg_info), result);
}
static void imap_check(mailmessage * msg_info)
{
get_ancestor(msg_info)->msg_flags = msg_info->msg_flags;
mailmessage_check(get_ancestor(msg_info));
get_ancestor(msg_info)->msg_flags = NULL;
}
static void imap_fetch_result_free(mailmessage * msg_info,
char * msg)
{
mailmessage_fetch_result_free(get_ancestor(msg_info), msg);
}
static void imap_uninitialize(mailmessage * msg_info)
{
mailmessage_free(get_ancestor(msg_info));
msg_info->msg_data = NULL;
}
static int mhdriver_cached_build_folder_name(mailsession * session, const char * mb,
const char * name, char ** result)
{
return mailsession_build_folder_name(get_ancestor(session),
mb, name, result);
}
static int mhdriver_cached_remove_message(mailsession * session, uint32_t num)
{
return mailsession_remove_message(get_ancestor(session), num);
}
static int mhdriver_cached_unsubscribe_folder(mailsession * session,
const char * mb)
{
return mailsession_unsubscribe_folder(get_ancestor(session), mb);
}
static int mhdriver_cached_lsub_folders(mailsession * session, const char * mb,
struct mail_list ** result)
{
return mailsession_lsub_folders(get_ancestor(session), mb, result);
}
RRGNode* RRG::_find_ancestor(RRGNode* p_node) {
return get_ancestor( p_node );
}
static int mhdriver_cached_messages_number(mailsession * session, const char * mb,
uint32_t * result)
{
return mailsession_messages_number(get_ancestor(session), mb, result);
}
