Your code is unnecessarily complex, and I'm not quite following your intent. Are you updated all contacts if all Obj__c are terminated? Or is it supposed to be if all objects on one contact are terminated? If you're looking to update each contact based on their children records, you might find it easier to do the following:

trigger TestTrigger1 on Obj__c(after insert, after update)
{
	Set<Id> set_ContactIds = new Set<Id>();
		for(Obj__c obj:Trigger.new)
			set_ContactIds.add(obj.Contact__c);
			
	List<Contact> contacts = new List<Contact>();
	
	for(Contact c:[select id,(select id,field__c,field2__c,status__c from objs__r where status__c in ('terminated','current')])
	{
		Integer current = 0, terminated = 0;
		for(Obj__c obj:c.objs__r)
			if(objs.status__c=='Current')
				current++;
			else
				terminated++;
		if(c.objs__r.size()==current)
		{
			// ALL RECORDS FOR THIS CONTACT ARE CURRENT
			c.field__c = c.objs__r[0].field__c;
			// ... more stuff
		}
		if(c.objs__r.size()==terminated)
		{
			// ALL RECORDS FOR THIS CONTACT ARE TERMINATED
			c.field2__c = c.objs__r[0].field2__c;
			// ... more stuff
		}
		// add this contact to be updated
		contacts.add(c);
		
	}
	update contacts;
}

In this code, I find all contacts (remember, you're in a trigger, so you don't have to query Obj__c for any information on any record included in an insert/update, because all fields will have their current database values). Next, we do a query to find all contacts with their respective Obj__c records (use the "relationship name" from the lookup field to determine the name to use for the query, remembering to add "__r"). Finally, iterate through the objects and perform your logic based on the results. In this example, we don't use any maps, only two queries (sub-queries count as one additional query), and the results are automatically structured for us in a way that we don't have to iterate through very long lists more than once to get our results.

In general, most triggers will be in this form: Gather a list of values for a query, iterate through a query result, and then perform any final logic. This sort of structure is generally an O(n) algorithm, meaning that the number of elements involved will scale your script usage linearly. Placing a for-loop that covers an entire array inside of another for-loop that covers an entire array creates an O(m*n) or O(n^2) algorithm, which scales very quickly. For example, if you have 5 contacts with 5 objects each, your algorithm would approach 5^3 script iterations, or 125. Adding a sixth contact adds at minimum another 25 executions, assuming that the new contact had no objects of its own. By using a series of maps or a sub-query, the same 5 contacts with 5 objects each has effectively 25 iterations instead of 125.