[SalesForce] Syncing custom fields between QuoteLineItem and OpportunityLineItem

The code you have shared will not at all compile.

• use close brace here for (Opportunity childObj : Trigger.new)
• use childObj.AccountId instead of childObj.Account to access AccountId
• When you use relationship query be sure to use Opportunities instead of Opportunity.
• You should put Opportunity's Opp_Location__c into a List. Then use String.join() to add those with comma delimited.
• And finally update accounts.

Trigger

trigger UpdateAmount on Opportunity (after insert, after update) { 
  Map<ID, Account > parentOpps = new Map<ID, Account>(); 
  Set<Id> listIds = new Set<Id>();

  for (Opportunity childObj : Trigger.new) {
    listIds.add(childObj.AccountId);
  }

  parentOpps = new Map<Id, Account>([SELECT id, Location_Type__c ,
                                        (SELECT ID, Opp_Location__c  FROM Opportunities) 
                                    FROM Account WHERE ID IN :listIds]);

  List<Account> lstAccount = new List<Account>();

  for(Account acct:parentOpps.values())
  {  
      List<String> strType = new List<String>();
      for(Opportunity oppty:acct.Opportunities)
      {
          strType.add(oppty.Opp_Location__c);
      }
      acct.Location_Type__c = String.join(strType,',');

  }

  update parentOpps.values();
}

Find my comments in the code.

Step 1: Retrieve Account Information from this SOQL

Map<Id, Opportunity> oppsMap = new Map<Id, Opportunity>(
        [SELECT Id, Account.OwnerId, Account.Owner.Name , AccountId FROM Opportunity WHERE Id IN :oppIds]);

Step 2: Then store them into oliAccountMap like this:

// On Insert we add to all products
    for(OpportunityLineItem oppyLine : newList)
    {
        olikeys.add(oppsMap.get(oppyLine.OpportunityId).AccountId + '-' + prodsMap.get(oppyLine.Product2Id).Practice__c);
        //put information respective to OLI.
        oliAccountMap.put(oppyLine.Id, oppsMap.get(oppyLine.OpportunityId).Account.OwnerId + '-' + oppsMap.get(oppyLine.OpportunityId).Account.Owner.Name);
        olis.add(oppyLine);
    }

Step 3: Pass oliAccountMap as a parameter of getResParty method.

Step 4: Then retrieve elements from oliAccountMap

String[] strAccountInfo = oliAccountMap.get(strKey).split('-');

 newResParty.User__c = strAccountInfo[0];  //Account's OwnerId
 newResParty.Team_Name__c = strAccountInfo[1]; //Account's Owner Name

Entire code

public without sharing class NPD_Responsible_Party_Locator
{

public static void filterInsert(List<OpportunityLineItem> newList)
{
    List<OpportunityLineItem> olis = new List<OpportunityLineItem>();
    Set<String> olikeys = new Set<String>();
    Set<Id> oppIds = new Set<Id>();
    Set<Id> prodIds = new Set<Id>();

    Map<String, String> oliAccountMap = new Map<String, String>();

    // Create a set of all the unique Opp Ids that we need to query for
    for(OpportunityLineItem oliO : newList)
        oppIds.add(oliO.OpportunityId);

    // Create a map so that Opportunity is locatable by its Id (key)
    Map<Id, Opportunity> oppsMap = new Map<Id, Opportunity>(
        [SELECT Id, Account.OwnerId, Account.Owner.Name , AccountId FROM Opportunity WHERE Id IN :oppIds]);


    // Create a set of all the unique Product Ids that we need to query for
    for(OpportunityLineItem oliP : newList)
        prodIds.add(oliP.Product2Id);

    // Create a map so that the Product is locatable by its Id (key)
    Map<Id, Product2> prodsMap = new Map<Id, Product2>(
        [SELECT Id, Formula_LOB__c, Practice__c, Practice__r.Key_Type__c FROM Product2 WHERE Id IN :prodIds]);

    // On Insert we add to all products
    for(OpportunityLineItem oppyLine : newList)
    {
        olikeys.add(oppsMap.get(oppyLine.OpportunityId).AccountId + '-' + prodsMap.get(oppyLine.Product2Id).Practice__c);
        //put information respective to OLI.
        oliAccountMap.put(oppyLine.Id, oppsMap.get(oppyLine.OpportunityId).Account.OwnerId + '-' + oppsMap.get(oppyLine.OpportunityId).Account.Owner.Name);
        olis.add(oppyLine);
    }

    Map<String, Responsible_Party__c> rmap = getResParty(olikeys,oliAccountMap);
    updateOLI(rmap, olis, oppsMap, prodsMap);
}

public static Map<String, Responsible_Party__c> getResParty(Set<String> olikeys, Map<String, String> oliAccountMap)
{
    Map<String, Responsible_Party__c> rmap = new Map<String, Responsible_Party__c>();

    for(Responsible_Party__c r : [SELECT    Id,
                                            Name,
                                            User__c,
                                            Sector__c,
                                            Key__c,
                                            OwnerId,
                                            Owner.Name,
                                  FROM      Responsible_Party__c
                                  WHERE     Key__c IN : olikeys])
    {
        rmap.put(r.Key__c, r);
    }

    //if record does not exists then create the record here
    List<Responsible_Party__c> rlst = new List<Responsible_Party__c>();
    Set<String> newKeySet = new Set<String>(); //capture Key__c for which records to be created. It will help to fetch newly created records.

    for(String strKey : olikeys)
    {
        if(!rmap.containsKey(strKey))
        {
            Responsible_Party__c newResParty = new Responsible_Party__c();
            newResParty.Key__c = strKey;
            newResParty.Name = 'Workflow Field Update';
            newResParty.Key_Type__c = 'Account - Practice';
            newResParty.Practice__c = strKey.right(18);
            String[] strAccountInfo = oliAccountMap.get(strKey).split('-');

            newResParty.User__c = strAccountInfo[0];  //Account's OwnerId
            newResParty.Team_Name__c = strAccountInfo[1]; //Account's Owner Name
            newResParty.Account__c = strKey.left(18);

            rlst.add(newResParty);
            newKeySet.add(strKey);
        }
    }
    insert rlst;

    //retrieve newly created values and add this to the map
    for(Responsible_Party__c r : [SELECT    Id,
                                            Name,
                                            User__c,
                                            Sector__c,
                                            Key__c
                                  FROM      Responsible_Party__c
                                  WHERE     Key__c IN : newKeySet])
    {
        rmap.put(r.Key__c, r);
    }
    return rmap;
}

public static void updateOLI(Map<String, Responsible_Party__c> rmap, List<OpportunityLineItem> olis, Map<Id, Opportunity> oppsMap, Map<Id, Product2> prodsMap)
{
    Responsible_Party__c r = new Responsible_Party__c();

    for(OpportunityLineItem o : olis)
    {
        r = rmap.get(oppsMap.get(o.OpportunityId).AccountId + '-' + prodsMap.get(o.Product2Id).Practice__c);

        if(r != null)
        {
            o.Responsible_Party__c = r.Id;
        }
        else{
            o.Responsible_Party__c = null;
        }
    }
}
}